CURL *hnd = curl_easy_init();

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

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, "AlphaSender=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders" {:form-params {:AlphaSender ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AlphaSender="

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

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

	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/v1/Services/:ServiceSid/AlphaSenders HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 12

AlphaSender=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AlphaSender="))
    .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, "AlphaSender=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

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

const data = 'AlphaSender=';

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

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

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

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders',
  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}}/v1/Services/:ServiceSid/AlphaSenders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({AlphaSender: ''})
};

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

$.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, "AlphaSender=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")
  .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/v1/Services/:ServiceSid/AlphaSenders',
  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({AlphaSender: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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('AlphaSender', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders',
  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('AlphaSender', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders';
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:[@"AlphaSender=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AlphaSender=",
  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}}/v1/Services/:ServiceSid/AlphaSenders', [
  'form_params' => [
    'AlphaSender' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders');
$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}}/v1/Services/:ServiceSid/AlphaSenders' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AlphaSender='

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

import http.client

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

payload = "AlphaSender="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/AlphaSenders", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

payload <- "AlphaSender="

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}}/v1/Services/:ServiceSid/AlphaSenders")

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 = "AlphaSender="

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

require 'faraday'

data = {
  :AlphaSender => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/AlphaSenders') 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}}/v1/Services/:ServiceSid/AlphaSenders";

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

    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}}/v1/Services/:ServiceSid/AlphaSenders \
  content-type:application/x-www-form-urlencoded \
  AlphaSender=''

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")! 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}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp"

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

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

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp"

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

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

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

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

}

POST /baseUrl/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp'
};

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp'
};

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

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandRegistrationSid/SmsOtp")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/a2p/BrandRegistrations");

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, "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/a2p/BrandRegistrations" {:form-params {:A2PProfileBundleSid ""
                                                                                    :BrandType ""
                                                                                    :CustomerProfileBundleSid ""
                                                                                    :Mock ""
                                                                                    :SkipAutomaticSecVet ""}})

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet="

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}}/v1/a2p/BrandRegistrations"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "A2PProfileBundleSid", "" },
        { "BrandType", "" },
        { "CustomerProfileBundleSid", "" },
        { "Mock", "" },
        { "SkipAutomaticSecVet", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations"

	payload := strings.NewReader("A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=")

	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/v1/a2p/BrandRegistrations HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 84

A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/a2p/BrandRegistrations")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet="))
    .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, "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/a2p/BrandRegistrations")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=")
  .asString();

const data = 'A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('A2PProfileBundleSid', '');
encodedParams.set('BrandType', '');
encodedParams.set('CustomerProfileBundleSid', '');
encodedParams.set('Mock', '');
encodedParams.set('SkipAutomaticSecVet', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations',
  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}}/v1/a2p/BrandRegistrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    A2PProfileBundleSid: '',
    BrandType: '',
    CustomerProfileBundleSid: '',
    Mock: '',
    SkipAutomaticSecVet: ''
  })
};

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}}/v1/a2p/BrandRegistrations',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    A2PProfileBundleSid: '',
    BrandType: '',
    CustomerProfileBundleSid: '',
    Mock: '',
    SkipAutomaticSecVet: ''
  }
};

$.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, "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations")
  .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/v1/a2p/BrandRegistrations',
  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({
  A2PProfileBundleSid: '',
  BrandType: '',
  CustomerProfileBundleSid: '',
  Mock: '',
  SkipAutomaticSecVet: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    A2PProfileBundleSid: '',
    BrandType: '',
    CustomerProfileBundleSid: '',
    Mock: '',
    SkipAutomaticSecVet: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations');

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

req.form({
  A2PProfileBundleSid: '',
  BrandType: '',
  CustomerProfileBundleSid: '',
  Mock: '',
  SkipAutomaticSecVet: ''
});

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('A2PProfileBundleSid', '');
encodedParams.set('BrandType', '');
encodedParams.set('CustomerProfileBundleSid', '');
encodedParams.set('Mock', '');
encodedParams.set('SkipAutomaticSecVet', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations',
  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('A2PProfileBundleSid', '');
encodedParams.set('BrandType', '');
encodedParams.set('CustomerProfileBundleSid', '');
encodedParams.set('Mock', '');
encodedParams.set('SkipAutomaticSecVet', '');

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations';
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:[@"A2PProfileBundleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BrandType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomerProfileBundleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Mock=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SkipAutomaticSecVet=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/a2p/BrandRegistrations"]
                                                       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}}/v1/a2p/BrandRegistrations" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=",
  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}}/v1/a2p/BrandRegistrations', [
  'form_params' => [
    'A2PProfileBundleSid' => '',
    'BrandType' => '',
    'CustomerProfileBundleSid' => '',
    'Mock' => '',
    'SkipAutomaticSecVet' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'A2PProfileBundleSid' => '',
  'BrandType' => '',
  'CustomerProfileBundleSid' => '',
  'Mock' => '',
  'SkipAutomaticSecVet' => ''
]);

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

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

append(new http\QueryString([
  'A2PProfileBundleSid' => '',
  'BrandType' => '',
  'CustomerProfileBundleSid' => '',
  'Mock' => '',
  'SkipAutomaticSecVet' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations');
$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}}/v1/a2p/BrandRegistrations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet='

import http.client

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

payload = "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet="

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

conn.request("POST", "/baseUrl/v1/a2p/BrandRegistrations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations"

payload = {
    "A2PProfileBundleSid": "",
    "BrandType": "",
    "CustomerProfileBundleSid": "",
    "Mock": "",
    "SkipAutomaticSecVet": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations"

payload <- "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet="

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}}/v1/a2p/BrandRegistrations")

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 = "A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet="

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

require 'faraday'

data = {
  :A2PProfileBundleSid => "",
  :BrandType => "",
  :CustomerProfileBundleSid => "",
  :Mock => "",
  :SkipAutomaticSecVet => "",
}

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

response = conn.post('/baseUrl/v1/a2p/BrandRegistrations') 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}}/v1/a2p/BrandRegistrations";

    let payload = json!({
        "A2PProfileBundleSid": "",
        "BrandType": "",
        "CustomerProfileBundleSid": "",
        "Mock": "",
        "SkipAutomaticSecVet": ""
    });

    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}}/v1/a2p/BrandRegistrations \
  content-type:application/x-www-form-urlencoded \
  A2PProfileBundleSid='' \
  BrandType='' \
  CustomerProfileBundleSid='' \
  Mock='' \
  SkipAutomaticSecVet=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'A2PProfileBundleSid=&BrandType=&CustomerProfileBundleSid=&Mock=&SkipAutomaticSecVet=' \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations

import Foundation

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

let postData = NSMutableData(data: "A2PProfileBundleSid=".data(using: String.Encoding.utf8)!)
postData.append("&BrandType=".data(using: String.Encoding.utf8)!)
postData.append("&CustomerProfileBundleSid=".data(using: String.Encoding.utf8)!)
postData.append("&Mock=".data(using: String.Encoding.utf8)!)
postData.append("&SkipAutomaticSecVet=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations")! 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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings");

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, "VettingId=&VettingProvider=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings" {:form-params {:VettingId ""
                                                                                                       :VettingProvider ""}})

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "VettingId=&VettingProvider="

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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "VettingId", "" },
        { "VettingProvider", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "VettingId=&VettingProvider=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

	payload := strings.NewReader("VettingId=&VettingProvider=")

	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/v1/a2p/BrandRegistrations/:BrandSid/Vettings HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 27

VettingId=&VettingProvider=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("VettingId=&VettingProvider=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("VettingId=&VettingProvider="))
    .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, "VettingId=&VettingProvider=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("VettingId=&VettingProvider=")
  .asString();

const data = 'VettingId=&VettingProvider=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({VettingId: '', VettingProvider: ''})
};

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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    VettingId: '',
    VettingProvider: ''
  }
};

$.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, "VettingId=&VettingProvider=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .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/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  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({VettingId: '', VettingProvider: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {VettingId: '', VettingProvider: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');

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

req.form({
  VettingId: '',
  VettingProvider: ''
});

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('VettingId', '');
encodedParams.set('VettingProvider', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  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('VettingId', '');
encodedParams.set('VettingProvider', '');

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings';
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:[@"VettingId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&VettingProvider=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"]
                                                       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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "VettingId=&VettingProvider=" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "VettingId=&VettingProvider=",
  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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings', [
  'form_params' => [
    'VettingId' => '',
    'VettingProvider' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(new http\QueryString([
  'VettingId' => '',
  'VettingProvider' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');
$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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'VettingId=&VettingProvider='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'VettingId=&VettingProvider='

import http.client

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

payload = "VettingId=&VettingProvider="

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

conn.request("POST", "/baseUrl/v1/a2p/BrandRegistrations/:BrandSid/Vettings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

payload <- "VettingId=&VettingProvider="

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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")

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 = "VettingId=&VettingProvider="

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

require 'faraday'

data = {
  :VettingId => "",
  :VettingProvider => "",
}

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

response = conn.post('/baseUrl/v1/a2p/BrandRegistrations/:BrandSid/Vettings') 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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings";

    let payload = json!({
        "VettingId": "",
        "VettingProvider": ""
    });

    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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings \
  content-type:application/x-www-form-urlencoded \
  VettingId='' \
  VettingProvider=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'VettingId=&VettingProvider=' \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")! 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}}/v1/Services/PreregisteredUsa2p");

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, "CampaignId=&MessagingServiceSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/PreregisteredUsa2p" {:form-params {:CampaignId ""
                                                                                         :MessagingServiceSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/PreregisteredUsa2p"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "CampaignId=&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}}/v1/Services/PreregisteredUsa2p"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "CampaignId", "" },
        { "MessagingServiceSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/PreregisteredUsa2p"

	payload := strings.NewReader("CampaignId=&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/v1/Services/PreregisteredUsa2p HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 32

CampaignId=&MessagingServiceSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/PreregisteredUsa2p"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("CampaignId=&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, "CampaignId=&MessagingServiceSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/PreregisteredUsa2p")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/PreregisteredUsa2p")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("CampaignId=&MessagingServiceSid=")
  .asString();

const data = 'CampaignId=&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}}/v1/Services/PreregisteredUsa2p');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/PreregisteredUsa2p',
  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}}/v1/Services/PreregisteredUsa2p';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({CampaignId: '', 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}}/v1/Services/PreregisteredUsa2p',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    CampaignId: '',
    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, "CampaignId=&MessagingServiceSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/PreregisteredUsa2p")
  .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/v1/Services/PreregisteredUsa2p',
  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({CampaignId: '', MessagingServiceSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/PreregisteredUsa2p',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {CampaignId: '', 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}}/v1/Services/PreregisteredUsa2p');

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

req.form({
  CampaignId: '',
  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('CampaignId', '');
encodedParams.set('MessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/PreregisteredUsa2p',
  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('CampaignId', '');
encodedParams.set('MessagingServiceSid', '');

const url = '{{baseUrl}}/v1/Services/PreregisteredUsa2p';
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:[@"CampaignId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/Services/PreregisteredUsa2p",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "CampaignId=&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}}/v1/Services/PreregisteredUsa2p', [
  'form_params' => [
    'CampaignId' => '',
    'MessagingServiceSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/PreregisteredUsa2p');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Services/PreregisteredUsa2p');
$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}}/v1/Services/PreregisteredUsa2p' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CampaignId=&MessagingServiceSid='

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

import http.client

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

payload = "CampaignId=&MessagingServiceSid="

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

conn.request("POST", "/baseUrl/v1/Services/PreregisteredUsa2p", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/PreregisteredUsa2p"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/PreregisteredUsa2p"

payload <- "CampaignId=&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}}/v1/Services/PreregisteredUsa2p")

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 = "CampaignId=&MessagingServiceSid="

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

require 'faraday'

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

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

response = conn.post('/baseUrl/v1/Services/PreregisteredUsa2p') 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}}/v1/Services/PreregisteredUsa2p";

    let payload = json!({
        "CampaignId": "",
        "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}}/v1/Services/PreregisteredUsa2p \
  content-type:application/x-www-form-urlencoded \
  CampaignId='' \
  MessagingServiceSid=''

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/PreregisteredUsa2p")! 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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

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

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

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

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

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

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

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

}

POST /baseUrl/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid'
};

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/: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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid'
};

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

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid" in

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

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")

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

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

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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, "PhoneNumberSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers" {:form-params {:PhoneNumberSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "PhoneNumberSid="

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

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

	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/v1/Services/:ServiceSid/PhoneNumbers HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 15

PhoneNumberSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("PhoneNumberSid="))
    .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, "PhoneNumberSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

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

const data = 'PhoneNumberSid=';

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

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

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

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers',
  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}}/v1/Services/:ServiceSid/PhoneNumbers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({PhoneNumberSid: ''})
};

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

$.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, "PhoneNumberSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")
  .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/v1/Services/:ServiceSid/PhoneNumbers',
  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({PhoneNumberSid: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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('PhoneNumberSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers',
  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('PhoneNumberSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers';
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:[@"PhoneNumberSid=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "PhoneNumberSid=",
  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}}/v1/Services/:ServiceSid/PhoneNumbers', [
  'form_params' => [
    'PhoneNumberSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers');
$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}}/v1/Services/:ServiceSid/PhoneNumbers' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'PhoneNumberSid='

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

import http.client

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

payload = "PhoneNumberSid="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/PhoneNumbers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

payload <- "PhoneNumberSid="

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}}/v1/Services/:ServiceSid/PhoneNumbers")

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 = "PhoneNumberSid="

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

require 'faraday'

data = {
  :PhoneNumberSid => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/PhoneNumbers') 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}}/v1/Services/:ServiceSid/PhoneNumbers";

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

    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}}/v1/Services/:ServiceSid/PhoneNumbers \
  content-type:application/x-www-form-urlencoded \
  PhoneNumberSid=''

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")! 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}}/v1/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, "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services" {:form-params {:AreaCodeGeomatch ""
                                                                      :FallbackMethod ""
                                                                      :FallbackToLongCode ""
                                                                      :FallbackUrl ""
                                                                      :FriendlyName ""
                                                                      :InboundMethod ""
                                                                      :InboundRequestUrl ""
                                                                      :MmsConverter ""
                                                                      :ScanMessageContent ""
                                                                      :SmartEncoding ""
                                                                      :StatusCallback ""
                                                                      :StickySender ""
                                                                      :SynchronousValidation ""
                                                                      :UseInboundWebhookOnNumber ""
                                                                      :Usecase ""
                                                                      :ValidityPeriod ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

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}}/v1/Services"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AreaCodeGeomatch", "" },
        { "FallbackMethod", "" },
        { "FallbackToLongCode", "" },
        { "FallbackUrl", "" },
        { "FriendlyName", "" },
        { "InboundMethod", "" },
        { "InboundRequestUrl", "" },
        { "MmsConverter", "" },
        { "ScanMessageContent", "" },
        { "SmartEncoding", "" },
        { "StatusCallback", "" },
        { "StickySender", "" },
        { "SynchronousValidation", "" },
        { "UseInboundWebhookOnNumber", "" },
        { "Usecase", "" },
        { "ValidityPeriod", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services"

	payload := strings.NewReader("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")

	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/v1/Services HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 268

AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="))
    .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, "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")
  .asString();

const data = 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=';

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

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

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AreaCodeGeomatch', '');
encodedParams.set('FallbackMethod', '');
encodedParams.set('FallbackToLongCode', '');
encodedParams.set('FallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('InboundMethod', '');
encodedParams.set('InboundRequestUrl', '');
encodedParams.set('MmsConverter', '');
encodedParams.set('ScanMessageContent', '');
encodedParams.set('SmartEncoding', '');
encodedParams.set('StatusCallback', '');
encodedParams.set('StickySender', '');
encodedParams.set('SynchronousValidation', '');
encodedParams.set('UseInboundWebhookOnNumber', '');
encodedParams.set('Usecase', '');
encodedParams.set('ValidityPeriod', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/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}}/v1/Services';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AreaCodeGeomatch: '',
    FallbackMethod: '',
    FallbackToLongCode: '',
    FallbackUrl: '',
    FriendlyName: '',
    InboundMethod: '',
    InboundRequestUrl: '',
    MmsConverter: '',
    ScanMessageContent: '',
    SmartEncoding: '',
    StatusCallback: '',
    StickySender: '',
    SynchronousValidation: '',
    UseInboundWebhookOnNumber: '',
    Usecase: '',
    ValidityPeriod: ''
  })
};

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}}/v1/Services',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AreaCodeGeomatch: '',
    FallbackMethod: '',
    FallbackToLongCode: '',
    FallbackUrl: '',
    FriendlyName: '',
    InboundMethod: '',
    InboundRequestUrl: '',
    MmsConverter: '',
    ScanMessageContent: '',
    SmartEncoding: '',
    StatusCallback: '',
    StickySender: '',
    SynchronousValidation: '',
    UseInboundWebhookOnNumber: '',
    Usecase: '',
    ValidityPeriod: ''
  }
};

$.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, "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/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/v1/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({
  AreaCodeGeomatch: '',
  FallbackMethod: '',
  FallbackToLongCode: '',
  FallbackUrl: '',
  FriendlyName: '',
  InboundMethod: '',
  InboundRequestUrl: '',
  MmsConverter: '',
  ScanMessageContent: '',
  SmartEncoding: '',
  StatusCallback: '',
  StickySender: '',
  SynchronousValidation: '',
  UseInboundWebhookOnNumber: '',
  Usecase: '',
  ValidityPeriod: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AreaCodeGeomatch: '',
    FallbackMethod: '',
    FallbackToLongCode: '',
    FallbackUrl: '',
    FriendlyName: '',
    InboundMethod: '',
    InboundRequestUrl: '',
    MmsConverter: '',
    ScanMessageContent: '',
    SmartEncoding: '',
    StatusCallback: '',
    StickySender: '',
    SynchronousValidation: '',
    UseInboundWebhookOnNumber: '',
    Usecase: '',
    ValidityPeriod: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services');

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

req.form({
  AreaCodeGeomatch: '',
  FallbackMethod: '',
  FallbackToLongCode: '',
  FallbackUrl: '',
  FriendlyName: '',
  InboundMethod: '',
  InboundRequestUrl: '',
  MmsConverter: '',
  ScanMessageContent: '',
  SmartEncoding: '',
  StatusCallback: '',
  StickySender: '',
  SynchronousValidation: '',
  UseInboundWebhookOnNumber: '',
  Usecase: '',
  ValidityPeriod: ''
});

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('AreaCodeGeomatch', '');
encodedParams.set('FallbackMethod', '');
encodedParams.set('FallbackToLongCode', '');
encodedParams.set('FallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('InboundMethod', '');
encodedParams.set('InboundRequestUrl', '');
encodedParams.set('MmsConverter', '');
encodedParams.set('ScanMessageContent', '');
encodedParams.set('SmartEncoding', '');
encodedParams.set('StatusCallback', '');
encodedParams.set('StickySender', '');
encodedParams.set('SynchronousValidation', '');
encodedParams.set('UseInboundWebhookOnNumber', '');
encodedParams.set('Usecase', '');
encodedParams.set('ValidityPeriod', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/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('AreaCodeGeomatch', '');
encodedParams.set('FallbackMethod', '');
encodedParams.set('FallbackToLongCode', '');
encodedParams.set('FallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('InboundMethod', '');
encodedParams.set('InboundRequestUrl', '');
encodedParams.set('MmsConverter', '');
encodedParams.set('ScanMessageContent', '');
encodedParams.set('SmartEncoding', '');
encodedParams.set('StatusCallback', '');
encodedParams.set('StickySender', '');
encodedParams.set('SynchronousValidation', '');
encodedParams.set('UseInboundWebhookOnNumber', '');
encodedParams.set('Usecase', '');
encodedParams.set('ValidityPeriod', '');

const url = '{{baseUrl}}/v1/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:[@"AreaCodeGeomatch=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackToLongCode=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&InboundMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&InboundRequestUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MmsConverter=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ScanMessageContent=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SmartEncoding=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&StatusCallback=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&StickySender=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SynchronousValidation=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UseInboundWebhookOnNumber=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Usecase=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ValidityPeriod=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/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}}/v1/Services" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=" in

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

 "{{baseUrl}}/v1/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 => "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=",
  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}}/v1/Services', [
  'form_params' => [
    'AreaCodeGeomatch' => '',
    'FallbackMethod' => '',
    'FallbackToLongCode' => '',
    'FallbackUrl' => '',
    'FriendlyName' => '',
    'InboundMethod' => '',
    'InboundRequestUrl' => '',
    'MmsConverter' => '',
    'ScanMessageContent' => '',
    'SmartEncoding' => '',
    'StatusCallback' => '',
    'StickySender' => '',
    'SynchronousValidation' => '',
    'UseInboundWebhookOnNumber' => '',
    'Usecase' => '',
    'ValidityPeriod' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AreaCodeGeomatch' => '',
  'FallbackMethod' => '',
  'FallbackToLongCode' => '',
  'FallbackUrl' => '',
  'FriendlyName' => '',
  'InboundMethod' => '',
  'InboundRequestUrl' => '',
  'MmsConverter' => '',
  'ScanMessageContent' => '',
  'SmartEncoding' => '',
  'StatusCallback' => '',
  'StickySender' => '',
  'SynchronousValidation' => '',
  'UseInboundWebhookOnNumber' => '',
  'Usecase' => '',
  'ValidityPeriod' => ''
]);

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

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

append(new http\QueryString([
  'AreaCodeGeomatch' => '',
  'FallbackMethod' => '',
  'FallbackToLongCode' => '',
  'FallbackUrl' => '',
  'FriendlyName' => '',
  'InboundMethod' => '',
  'InboundRequestUrl' => '',
  'MmsConverter' => '',
  'ScanMessageContent' => '',
  'SmartEncoding' => '',
  'StatusCallback' => '',
  'StickySender' => '',
  'SynchronousValidation' => '',
  'UseInboundWebhookOnNumber' => '',
  'Usecase' => '',
  'ValidityPeriod' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/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}}/v1/Services' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod='

import http.client

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

payload = "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

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

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

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

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

import requests

url = "{{baseUrl}}/v1/Services"

payload = {
    "AreaCodeGeomatch": "",
    "FallbackMethod": "",
    "FallbackToLongCode": "",
    "FallbackUrl": "",
    "FriendlyName": "",
    "InboundMethod": "",
    "InboundRequestUrl": "",
    "MmsConverter": "",
    "ScanMessageContent": "",
    "SmartEncoding": "",
    "StatusCallback": "",
    "StickySender": "",
    "SynchronousValidation": "",
    "UseInboundWebhookOnNumber": "",
    "Usecase": "",
    "ValidityPeriod": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services"

payload <- "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

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}}/v1/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 = "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

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

require 'faraday'

data = {
  :AreaCodeGeomatch => "",
  :FallbackMethod => "",
  :FallbackToLongCode => "",
  :FallbackUrl => "",
  :FriendlyName => "",
  :InboundMethod => "",
  :InboundRequestUrl => "",
  :MmsConverter => "",
  :ScanMessageContent => "",
  :SmartEncoding => "",
  :StatusCallback => "",
  :StickySender => "",
  :SynchronousValidation => "",
  :UseInboundWebhookOnNumber => "",
  :Usecase => "",
  :ValidityPeriod => "",
}

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

response = conn.post('/baseUrl/v1/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}}/v1/Services";

    let payload = json!({
        "AreaCodeGeomatch": "",
        "FallbackMethod": "",
        "FallbackToLongCode": "",
        "FallbackUrl": "",
        "FriendlyName": "",
        "InboundMethod": "",
        "InboundRequestUrl": "",
        "MmsConverter": "",
        "ScanMessageContent": "",
        "SmartEncoding": "",
        "StatusCallback": "",
        "StickySender": "",
        "SynchronousValidation": "",
        "UseInboundWebhookOnNumber": "",
        "Usecase": "",
        "ValidityPeriod": ""
    });

    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}}/v1/Services \
  content-type:application/x-www-form-urlencoded \
  AreaCodeGeomatch='' \
  FallbackMethod='' \
  FallbackToLongCode='' \
  FallbackUrl='' \
  FriendlyName='' \
  InboundMethod='' \
  InboundRequestUrl='' \
  MmsConverter='' \
  ScanMessageContent='' \
  SmartEncoding='' \
  StatusCallback='' \
  StickySender='' \
  SynchronousValidation='' \
  UseInboundWebhookOnNumber='' \
  Usecase='' \
  ValidityPeriod=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=' \
  --output-document \
  - {{baseUrl}}/v1/Services

import Foundation

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

let postData = NSMutableData(data: "AreaCodeGeomatch=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackMethod=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackToLongCode=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&InboundMethod=".data(using: String.Encoding.utf8)!)
postData.append("&InboundRequestUrl=".data(using: String.Encoding.utf8)!)
postData.append("&MmsConverter=".data(using: String.Encoding.utf8)!)
postData.append("&ScanMessageContent=".data(using: String.Encoding.utf8)!)
postData.append("&SmartEncoding=".data(using: String.Encoding.utf8)!)
postData.append("&StatusCallback=".data(using: String.Encoding.utf8)!)
postData.append("&StickySender=".data(using: String.Encoding.utf8)!)
postData.append("&SynchronousValidation=".data(using: String.Encoding.utf8)!)
postData.append("&UseInboundWebhookOnNumber=".data(using: String.Encoding.utf8)!)
postData.append("&Usecase=".data(using: String.Encoding.utf8)!)
postData.append("&ValidityPeriod=".data(using: String.Encoding.utf8)!)

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

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, "ShortCodeSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes" {:form-params {:ShortCodeSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ShortCodeSid="

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

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

	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/v1/Services/:ServiceSid/ShortCodes HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 13

ShortCodeSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ShortCodeSid="))
    .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, "ShortCodeSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

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

const data = 'ShortCodeSid=';

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

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

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

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes',
  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}}/v1/Services/:ServiceSid/ShortCodes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({ShortCodeSid: ''})
};

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

$.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, "ShortCodeSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")
  .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/v1/Services/:ServiceSid/ShortCodes',
  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({ShortCodeSid: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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('ShortCodeSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes',
  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('ShortCodeSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes';
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:[@"ShortCodeSid=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ShortCodeSid=",
  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}}/v1/Services/:ServiceSid/ShortCodes', [
  'form_params' => [
    'ShortCodeSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes');
$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}}/v1/Services/:ServiceSid/ShortCodes' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ShortCodeSid='

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

import http.client

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

payload = "ShortCodeSid="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/ShortCodes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

payload <- "ShortCodeSid="

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}}/v1/Services/:ServiceSid/ShortCodes")

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 = "ShortCodeSid="

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

require 'faraday'

data = {
  :ShortCodeSid => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/ShortCodes') 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}}/v1/Services/:ServiceSid/ShortCodes";

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

    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}}/v1/Services/:ServiceSid/ShortCodes \
  content-type:application/x-www-form-urlencoded \
  ShortCodeSid=''

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")! 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}}/v1/Tollfree/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, "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Tollfree/Verifications" {:form-params {:AdditionalInformation ""
                                                                                    :BusinessCity ""
                                                                                    :BusinessContactEmail ""
                                                                                    :BusinessContactFirstName ""
                                                                                    :BusinessContactLastName ""
                                                                                    :BusinessContactPhone ""
                                                                                    :BusinessCountry ""
                                                                                    :BusinessName ""
                                                                                    :BusinessPostalCode ""
                                                                                    :BusinessStateProvinceRegion ""
                                                                                    :BusinessStreetAddress ""
                                                                                    :BusinessStreetAddress2 ""
                                                                                    :BusinessWebsite ""
                                                                                    :CustomerProfileSid ""
                                                                                    :ExternalReferenceId ""
                                                                                    :MessageVolume ""
                                                                                    :NotificationEmail ""
                                                                                    :OptInImageUrls ""
                                                                                    :OptInType ""
                                                                                    :ProductionMessageSample ""
                                                                                    :TollfreePhoneNumberSid ""
                                                                                    :UseCaseCategories ""
                                                                                    :UseCaseSummary ""}})

require "http/client"

url = "{{baseUrl}}/v1/Tollfree/Verifications"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary="

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}}/v1/Tollfree/Verifications"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AdditionalInformation", "" },
        { "BusinessCity", "" },
        { "BusinessContactEmail", "" },
        { "BusinessContactFirstName", "" },
        { "BusinessContactLastName", "" },
        { "BusinessContactPhone", "" },
        { "BusinessCountry", "" },
        { "BusinessName", "" },
        { "BusinessPostalCode", "" },
        { "BusinessStateProvinceRegion", "" },
        { "BusinessStreetAddress", "" },
        { "BusinessStreetAddress2", "" },
        { "BusinessWebsite", "" },
        { "CustomerProfileSid", "" },
        { "ExternalReferenceId", "" },
        { "MessageVolume", "" },
        { "NotificationEmail", "" },
        { "OptInImageUrls", "" },
        { "OptInType", "" },
        { "ProductionMessageSample", "" },
        { "TollfreePhoneNumberSid", "" },
        { "UseCaseCategories", "" },
        { "UseCaseSummary", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Tollfree/Verifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Tollfree/Verifications"

	payload := strings.NewReader("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=")

	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/v1/Tollfree/Verifications HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 461

AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Tollfree/Verifications")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Tollfree/Verifications"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary="))
    .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, "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Tollfree/Verifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Tollfree/Verifications")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=")
  .asString();

const data = 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Tollfree/Verifications');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AdditionalInformation', '');
encodedParams.set('BusinessCity', '');
encodedParams.set('BusinessContactEmail', '');
encodedParams.set('BusinessContactFirstName', '');
encodedParams.set('BusinessContactLastName', '');
encodedParams.set('BusinessContactPhone', '');
encodedParams.set('BusinessCountry', '');
encodedParams.set('BusinessName', '');
encodedParams.set('BusinessPostalCode', '');
encodedParams.set('BusinessStateProvinceRegion', '');
encodedParams.set('BusinessStreetAddress', '');
encodedParams.set('BusinessStreetAddress2', '');
encodedParams.set('BusinessWebsite', '');
encodedParams.set('CustomerProfileSid', '');
encodedParams.set('ExternalReferenceId', '');
encodedParams.set('MessageVolume', '');
encodedParams.set('NotificationEmail', '');
encodedParams.set('OptInImageUrls', '');
encodedParams.set('OptInType', '');
encodedParams.set('ProductionMessageSample', '');
encodedParams.set('TollfreePhoneNumberSid', '');
encodedParams.set('UseCaseCategories', '');
encodedParams.set('UseCaseSummary', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AdditionalInformation: '',
    BusinessCity: '',
    BusinessContactEmail: '',
    BusinessContactFirstName: '',
    BusinessContactLastName: '',
    BusinessContactPhone: '',
    BusinessCountry: '',
    BusinessName: '',
    BusinessPostalCode: '',
    BusinessStateProvinceRegion: '',
    BusinessStreetAddress: '',
    BusinessStreetAddress2: '',
    BusinessWebsite: '',
    CustomerProfileSid: '',
    ExternalReferenceId: '',
    MessageVolume: '',
    NotificationEmail: '',
    OptInImageUrls: '',
    OptInType: '',
    ProductionMessageSample: '',
    TollfreePhoneNumberSid: '',
    UseCaseCategories: '',
    UseCaseSummary: ''
  })
};

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}}/v1/Tollfree/Verifications',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AdditionalInformation: '',
    BusinessCity: '',
    BusinessContactEmail: '',
    BusinessContactFirstName: '',
    BusinessContactLastName: '',
    BusinessContactPhone: '',
    BusinessCountry: '',
    BusinessName: '',
    BusinessPostalCode: '',
    BusinessStateProvinceRegion: '',
    BusinessStreetAddress: '',
    BusinessStreetAddress2: '',
    BusinessWebsite: '',
    CustomerProfileSid: '',
    ExternalReferenceId: '',
    MessageVolume: '',
    NotificationEmail: '',
    OptInImageUrls: '',
    OptInType: '',
    ProductionMessageSample: '',
    TollfreePhoneNumberSid: '',
    UseCaseCategories: '',
    UseCaseSummary: ''
  }
};

$.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, "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Tollfree/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/v1/Tollfree/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({
  AdditionalInformation: '',
  BusinessCity: '',
  BusinessContactEmail: '',
  BusinessContactFirstName: '',
  BusinessContactLastName: '',
  BusinessContactPhone: '',
  BusinessCountry: '',
  BusinessName: '',
  BusinessPostalCode: '',
  BusinessStateProvinceRegion: '',
  BusinessStreetAddress: '',
  BusinessStreetAddress2: '',
  BusinessWebsite: '',
  CustomerProfileSid: '',
  ExternalReferenceId: '',
  MessageVolume: '',
  NotificationEmail: '',
  OptInImageUrls: '',
  OptInType: '',
  ProductionMessageSample: '',
  TollfreePhoneNumberSid: '',
  UseCaseCategories: '',
  UseCaseSummary: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Tollfree/Verifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AdditionalInformation: '',
    BusinessCity: '',
    BusinessContactEmail: '',
    BusinessContactFirstName: '',
    BusinessContactLastName: '',
    BusinessContactPhone: '',
    BusinessCountry: '',
    BusinessName: '',
    BusinessPostalCode: '',
    BusinessStateProvinceRegion: '',
    BusinessStreetAddress: '',
    BusinessStreetAddress2: '',
    BusinessWebsite: '',
    CustomerProfileSid: '',
    ExternalReferenceId: '',
    MessageVolume: '',
    NotificationEmail: '',
    OptInImageUrls: '',
    OptInType: '',
    ProductionMessageSample: '',
    TollfreePhoneNumberSid: '',
    UseCaseCategories: '',
    UseCaseSummary: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Tollfree/Verifications');

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

req.form({
  AdditionalInformation: '',
  BusinessCity: '',
  BusinessContactEmail: '',
  BusinessContactFirstName: '',
  BusinessContactLastName: '',
  BusinessContactPhone: '',
  BusinessCountry: '',
  BusinessName: '',
  BusinessPostalCode: '',
  BusinessStateProvinceRegion: '',
  BusinessStreetAddress: '',
  BusinessStreetAddress2: '',
  BusinessWebsite: '',
  CustomerProfileSid: '',
  ExternalReferenceId: '',
  MessageVolume: '',
  NotificationEmail: '',
  OptInImageUrls: '',
  OptInType: '',
  ProductionMessageSample: '',
  TollfreePhoneNumberSid: '',
  UseCaseCategories: '',
  UseCaseSummary: ''
});

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('AdditionalInformation', '');
encodedParams.set('BusinessCity', '');
encodedParams.set('BusinessContactEmail', '');
encodedParams.set('BusinessContactFirstName', '');
encodedParams.set('BusinessContactLastName', '');
encodedParams.set('BusinessContactPhone', '');
encodedParams.set('BusinessCountry', '');
encodedParams.set('BusinessName', '');
encodedParams.set('BusinessPostalCode', '');
encodedParams.set('BusinessStateProvinceRegion', '');
encodedParams.set('BusinessStreetAddress', '');
encodedParams.set('BusinessStreetAddress2', '');
encodedParams.set('BusinessWebsite', '');
encodedParams.set('CustomerProfileSid', '');
encodedParams.set('ExternalReferenceId', '');
encodedParams.set('MessageVolume', '');
encodedParams.set('NotificationEmail', '');
encodedParams.set('OptInImageUrls', '');
encodedParams.set('OptInType', '');
encodedParams.set('ProductionMessageSample', '');
encodedParams.set('TollfreePhoneNumberSid', '');
encodedParams.set('UseCaseCategories', '');
encodedParams.set('UseCaseSummary', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Tollfree/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('AdditionalInformation', '');
encodedParams.set('BusinessCity', '');
encodedParams.set('BusinessContactEmail', '');
encodedParams.set('BusinessContactFirstName', '');
encodedParams.set('BusinessContactLastName', '');
encodedParams.set('BusinessContactPhone', '');
encodedParams.set('BusinessCountry', '');
encodedParams.set('BusinessName', '');
encodedParams.set('BusinessPostalCode', '');
encodedParams.set('BusinessStateProvinceRegion', '');
encodedParams.set('BusinessStreetAddress', '');
encodedParams.set('BusinessStreetAddress2', '');
encodedParams.set('BusinessWebsite', '');
encodedParams.set('CustomerProfileSid', '');
encodedParams.set('ExternalReferenceId', '');
encodedParams.set('MessageVolume', '');
encodedParams.set('NotificationEmail', '');
encodedParams.set('OptInImageUrls', '');
encodedParams.set('OptInType', '');
encodedParams.set('ProductionMessageSample', '');
encodedParams.set('TollfreePhoneNumberSid', '');
encodedParams.set('UseCaseCategories', '');
encodedParams.set('UseCaseSummary', '');

const url = '{{baseUrl}}/v1/Tollfree/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:[@"AdditionalInformation=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessCity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactEmail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactFirstName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactLastName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactPhone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessCountry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessPostalCode=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessStateProvinceRegion=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessStreetAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessStreetAddress2=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessWebsite=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomerProfileSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ExternalReferenceId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessageVolume=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NotificationEmail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptInImageUrls=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptInType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ProductionMessageSample=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TollfreePhoneNumberSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UseCaseCategories=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UseCaseSummary=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=" in

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

 "{{baseUrl}}/v1/Tollfree/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 => "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=",
  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}}/v1/Tollfree/Verifications', [
  'form_params' => [
    'AdditionalInformation' => '',
    'BusinessCity' => '',
    'BusinessContactEmail' => '',
    'BusinessContactFirstName' => '',
    'BusinessContactLastName' => '',
    'BusinessContactPhone' => '',
    'BusinessCountry' => '',
    'BusinessName' => '',
    'BusinessPostalCode' => '',
    'BusinessStateProvinceRegion' => '',
    'BusinessStreetAddress' => '',
    'BusinessStreetAddress2' => '',
    'BusinessWebsite' => '',
    'CustomerProfileSid' => '',
    'ExternalReferenceId' => '',
    'MessageVolume' => '',
    'NotificationEmail' => '',
    'OptInImageUrls' => '',
    'OptInType' => '',
    'ProductionMessageSample' => '',
    'TollfreePhoneNumberSid' => '',
    'UseCaseCategories' => '',
    'UseCaseSummary' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Tollfree/Verifications');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AdditionalInformation' => '',
  'BusinessCity' => '',
  'BusinessContactEmail' => '',
  'BusinessContactFirstName' => '',
  'BusinessContactLastName' => '',
  'BusinessContactPhone' => '',
  'BusinessCountry' => '',
  'BusinessName' => '',
  'BusinessPostalCode' => '',
  'BusinessStateProvinceRegion' => '',
  'BusinessStreetAddress' => '',
  'BusinessStreetAddress2' => '',
  'BusinessWebsite' => '',
  'CustomerProfileSid' => '',
  'ExternalReferenceId' => '',
  'MessageVolume' => '',
  'NotificationEmail' => '',
  'OptInImageUrls' => '',
  'OptInType' => '',
  'ProductionMessageSample' => '',
  'TollfreePhoneNumberSid' => '',
  'UseCaseCategories' => '',
  'UseCaseSummary' => ''
]);

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

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

append(new http\QueryString([
  'AdditionalInformation' => '',
  'BusinessCity' => '',
  'BusinessContactEmail' => '',
  'BusinessContactFirstName' => '',
  'BusinessContactLastName' => '',
  'BusinessContactPhone' => '',
  'BusinessCountry' => '',
  'BusinessName' => '',
  'BusinessPostalCode' => '',
  'BusinessStateProvinceRegion' => '',
  'BusinessStreetAddress' => '',
  'BusinessStreetAddress2' => '',
  'BusinessWebsite' => '',
  'CustomerProfileSid' => '',
  'ExternalReferenceId' => '',
  'MessageVolume' => '',
  'NotificationEmail' => '',
  'OptInImageUrls' => '',
  'OptInType' => '',
  'ProductionMessageSample' => '',
  'TollfreePhoneNumberSid' => '',
  'UseCaseCategories' => '',
  'UseCaseSummary' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Tollfree/Verifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary='

import http.client

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

payload = "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary="

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

conn.request("POST", "/baseUrl/v1/Tollfree/Verifications", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Tollfree/Verifications"

payload = {
    "AdditionalInformation": "",
    "BusinessCity": "",
    "BusinessContactEmail": "",
    "BusinessContactFirstName": "",
    "BusinessContactLastName": "",
    "BusinessContactPhone": "",
    "BusinessCountry": "",
    "BusinessName": "",
    "BusinessPostalCode": "",
    "BusinessStateProvinceRegion": "",
    "BusinessStreetAddress": "",
    "BusinessStreetAddress2": "",
    "BusinessWebsite": "",
    "CustomerProfileSid": "",
    "ExternalReferenceId": "",
    "MessageVolume": "",
    "NotificationEmail": "",
    "OptInImageUrls": "",
    "OptInType": "",
    "ProductionMessageSample": "",
    "TollfreePhoneNumberSid": "",
    "UseCaseCategories": "",
    "UseCaseSummary": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Tollfree/Verifications"

payload <- "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary="

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}}/v1/Tollfree/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 = "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary="

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

require 'faraday'

data = {
  :AdditionalInformation => "",
  :BusinessCity => "",
  :BusinessContactEmail => "",
  :BusinessContactFirstName => "",
  :BusinessContactLastName => "",
  :BusinessContactPhone => "",
  :BusinessCountry => "",
  :BusinessName => "",
  :BusinessPostalCode => "",
  :BusinessStateProvinceRegion => "",
  :BusinessStreetAddress => "",
  :BusinessStreetAddress2 => "",
  :BusinessWebsite => "",
  :CustomerProfileSid => "",
  :ExternalReferenceId => "",
  :MessageVolume => "",
  :NotificationEmail => "",
  :OptInImageUrls => "",
  :OptInType => "",
  :ProductionMessageSample => "",
  :TollfreePhoneNumberSid => "",
  :UseCaseCategories => "",
  :UseCaseSummary => "",
}

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

response = conn.post('/baseUrl/v1/Tollfree/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}}/v1/Tollfree/Verifications";

    let payload = json!({
        "AdditionalInformation": "",
        "BusinessCity": "",
        "BusinessContactEmail": "",
        "BusinessContactFirstName": "",
        "BusinessContactLastName": "",
        "BusinessContactPhone": "",
        "BusinessCountry": "",
        "BusinessName": "",
        "BusinessPostalCode": "",
        "BusinessStateProvinceRegion": "",
        "BusinessStreetAddress": "",
        "BusinessStreetAddress2": "",
        "BusinessWebsite": "",
        "CustomerProfileSid": "",
        "ExternalReferenceId": "",
        "MessageVolume": "",
        "NotificationEmail": "",
        "OptInImageUrls": "",
        "OptInType": "",
        "ProductionMessageSample": "",
        "TollfreePhoneNumberSid": "",
        "UseCaseCategories": "",
        "UseCaseSummary": ""
    });

    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}}/v1/Tollfree/Verifications \
  content-type:application/x-www-form-urlencoded \
  AdditionalInformation='' \
  BusinessCity='' \
  BusinessContactEmail='' \
  BusinessContactFirstName='' \
  BusinessContactLastName='' \
  BusinessContactPhone='' \
  BusinessCountry='' \
  BusinessName='' \
  BusinessPostalCode='' \
  BusinessStateProvinceRegion='' \
  BusinessStreetAddress='' \
  BusinessStreetAddress2='' \
  BusinessWebsite='' \
  CustomerProfileSid='' \
  ExternalReferenceId='' \
  MessageVolume='' \
  NotificationEmail='' \
  OptInImageUrls='' \
  OptInType='' \
  ProductionMessageSample='' \
  TollfreePhoneNumberSid='' \
  UseCaseCategories='' \
  UseCaseSummary=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&CustomerProfileSid=&ExternalReferenceId=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&TollfreePhoneNumberSid=&UseCaseCategories=&UseCaseSummary=' \
  --output-document \
  - {{baseUrl}}/v1/Tollfree/Verifications

import Foundation

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

let postData = NSMutableData(data: "AdditionalInformation=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessCity=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactEmail=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactFirstName=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactLastName=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactPhone=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessCountry=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessName=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessPostalCode=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessStateProvinceRegion=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessStreetAddress=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessStreetAddress2=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessWebsite=".data(using: String.Encoding.utf8)!)
postData.append("&CustomerProfileSid=".data(using: String.Encoding.utf8)!)
postData.append("&ExternalReferenceId=".data(using: String.Encoding.utf8)!)
postData.append("&MessageVolume=".data(using: String.Encoding.utf8)!)
postData.append("&NotificationEmail=".data(using: String.Encoding.utf8)!)
postData.append("&OptInImageUrls=".data(using: String.Encoding.utf8)!)
postData.append("&OptInType=".data(using: String.Encoding.utf8)!)
postData.append("&ProductionMessageSample=".data(using: String.Encoding.utf8)!)
postData.append("&TollfreePhoneNumberSid=".data(using: String.Encoding.utf8)!)
postData.append("&UseCaseCategories=".data(using: String.Encoding.utf8)!)
postData.append("&UseCaseSummary=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Tollfree/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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p");

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, "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p" {:form-params {:BrandRegistrationSid ""
                                                                                                            :Description ""
                                                                                                            :HasEmbeddedLinks ""
                                                                                                            :HasEmbeddedPhone ""
                                                                                                            :HelpKeywords ""
                                                                                                            :HelpMessage ""
                                                                                                            :MessageFlow ""
                                                                                                            :MessageSamples ""
                                                                                                            :OptInKeywords ""
                                                                                                            :OptInMessage ""
                                                                                                            :OptOutKeywords ""
                                                                                                            :OptOutMessage ""
                                                                                                            :UsAppToPersonUsecase ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase="

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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "BrandRegistrationSid", "" },
        { "Description", "" },
        { "HasEmbeddedLinks", "" },
        { "HasEmbeddedPhone", "" },
        { "HelpKeywords", "" },
        { "HelpMessage", "" },
        { "MessageFlow", "" },
        { "MessageSamples", "" },
        { "OptInKeywords", "" },
        { "OptInMessage", "" },
        { "OptOutKeywords", "" },
        { "OptOutMessage", "" },
        { "UsAppToPersonUsecase", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

	payload := strings.NewReader("BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=")

	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/v1/Services/:MessagingServiceSid/Compliance/Usa2p HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 208

BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase="))
    .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, "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=")
  .asString();

const data = 'BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('BrandRegistrationSid', '');
encodedParams.set('Description', '');
encodedParams.set('HasEmbeddedLinks', '');
encodedParams.set('HasEmbeddedPhone', '');
encodedParams.set('HelpKeywords', '');
encodedParams.set('HelpMessage', '');
encodedParams.set('MessageFlow', '');
encodedParams.set('MessageSamples', '');
encodedParams.set('OptInKeywords', '');
encodedParams.set('OptInMessage', '');
encodedParams.set('OptOutKeywords', '');
encodedParams.set('OptOutMessage', '');
encodedParams.set('UsAppToPersonUsecase', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    BrandRegistrationSid: '',
    Description: '',
    HasEmbeddedLinks: '',
    HasEmbeddedPhone: '',
    HelpKeywords: '',
    HelpMessage: '',
    MessageFlow: '',
    MessageSamples: '',
    OptInKeywords: '',
    OptInMessage: '',
    OptOutKeywords: '',
    OptOutMessage: '',
    UsAppToPersonUsecase: ''
  })
};

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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    BrandRegistrationSid: '',
    Description: '',
    HasEmbeddedLinks: '',
    HasEmbeddedPhone: '',
    HelpKeywords: '',
    HelpMessage: '',
    MessageFlow: '',
    MessageSamples: '',
    OptInKeywords: '',
    OptInMessage: '',
    OptOutKeywords: '',
    OptOutMessage: '',
    UsAppToPersonUsecase: ''
  }
};

$.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, "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .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/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  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({
  BrandRegistrationSid: '',
  Description: '',
  HasEmbeddedLinks: '',
  HasEmbeddedPhone: '',
  HelpKeywords: '',
  HelpMessage: '',
  MessageFlow: '',
  MessageSamples: '',
  OptInKeywords: '',
  OptInMessage: '',
  OptOutKeywords: '',
  OptOutMessage: '',
  UsAppToPersonUsecase: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    BrandRegistrationSid: '',
    Description: '',
    HasEmbeddedLinks: '',
    HasEmbeddedPhone: '',
    HelpKeywords: '',
    HelpMessage: '',
    MessageFlow: '',
    MessageSamples: '',
    OptInKeywords: '',
    OptInMessage: '',
    OptOutKeywords: '',
    OptOutMessage: '',
    UsAppToPersonUsecase: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');

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

req.form({
  BrandRegistrationSid: '',
  Description: '',
  HasEmbeddedLinks: '',
  HasEmbeddedPhone: '',
  HelpKeywords: '',
  HelpMessage: '',
  MessageFlow: '',
  MessageSamples: '',
  OptInKeywords: '',
  OptInMessage: '',
  OptOutKeywords: '',
  OptOutMessage: '',
  UsAppToPersonUsecase: ''
});

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('BrandRegistrationSid', '');
encodedParams.set('Description', '');
encodedParams.set('HasEmbeddedLinks', '');
encodedParams.set('HasEmbeddedPhone', '');
encodedParams.set('HelpKeywords', '');
encodedParams.set('HelpMessage', '');
encodedParams.set('MessageFlow', '');
encodedParams.set('MessageSamples', '');
encodedParams.set('OptInKeywords', '');
encodedParams.set('OptInMessage', '');
encodedParams.set('OptOutKeywords', '');
encodedParams.set('OptOutMessage', '');
encodedParams.set('UsAppToPersonUsecase', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  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('BrandRegistrationSid', '');
encodedParams.set('Description', '');
encodedParams.set('HasEmbeddedLinks', '');
encodedParams.set('HasEmbeddedPhone', '');
encodedParams.set('HelpKeywords', '');
encodedParams.set('HelpMessage', '');
encodedParams.set('MessageFlow', '');
encodedParams.set('MessageSamples', '');
encodedParams.set('OptInKeywords', '');
encodedParams.set('OptInMessage', '');
encodedParams.set('OptOutKeywords', '');
encodedParams.set('OptOutMessage', '');
encodedParams.set('UsAppToPersonUsecase', '');

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p';
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:[@"BrandRegistrationSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&HasEmbeddedLinks=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&HasEmbeddedPhone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&HelpKeywords=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&HelpMessage=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessageFlow=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessageSamples=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptInKeywords=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptInMessage=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptOutKeywords=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptOutMessage=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UsAppToPersonUsecase=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"]
                                                       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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=" in

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

 "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=",
  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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p', [
  'form_params' => [
    'BrandRegistrationSid' => '',
    'Description' => '',
    'HasEmbeddedLinks' => '',
    'HasEmbeddedPhone' => '',
    'HelpKeywords' => '',
    'HelpMessage' => '',
    'MessageFlow' => '',
    'MessageSamples' => '',
    'OptInKeywords' => '',
    'OptInMessage' => '',
    'OptOutKeywords' => '',
    'OptOutMessage' => '',
    'UsAppToPersonUsecase' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'BrandRegistrationSid' => '',
  'Description' => '',
  'HasEmbeddedLinks' => '',
  'HasEmbeddedPhone' => '',
  'HelpKeywords' => '',
  'HelpMessage' => '',
  'MessageFlow' => '',
  'MessageSamples' => '',
  'OptInKeywords' => '',
  'OptInMessage' => '',
  'OptOutKeywords' => '',
  'OptOutMessage' => '',
  'UsAppToPersonUsecase' => ''
]);

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

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

append(new http\QueryString([
  'BrandRegistrationSid' => '',
  'Description' => '',
  'HasEmbeddedLinks' => '',
  'HasEmbeddedPhone' => '',
  'HelpKeywords' => '',
  'HelpMessage' => '',
  'MessageFlow' => '',
  'MessageSamples' => '',
  'OptInKeywords' => '',
  'OptInMessage' => '',
  'OptOutKeywords' => '',
  'OptOutMessage' => '',
  'UsAppToPersonUsecase' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');
$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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase='

import http.client

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

payload = "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase="

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

conn.request("POST", "/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

payload = {
    "BrandRegistrationSid": "",
    "Description": "",
    "HasEmbeddedLinks": "",
    "HasEmbeddedPhone": "",
    "HelpKeywords": "",
    "HelpMessage": "",
    "MessageFlow": "",
    "MessageSamples": "",
    "OptInKeywords": "",
    "OptInMessage": "",
    "OptOutKeywords": "",
    "OptOutMessage": "",
    "UsAppToPersonUsecase": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

payload <- "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase="

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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")

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 = "BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase="

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

require 'faraday'

data = {
  :BrandRegistrationSid => "",
  :Description => "",
  :HasEmbeddedLinks => "",
  :HasEmbeddedPhone => "",
  :HelpKeywords => "",
  :HelpMessage => "",
  :MessageFlow => "",
  :MessageSamples => "",
  :OptInKeywords => "",
  :OptInMessage => "",
  :OptOutKeywords => "",
  :OptOutMessage => "",
  :UsAppToPersonUsecase => "",
}

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

response = conn.post('/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p') 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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p";

    let payload = json!({
        "BrandRegistrationSid": "",
        "Description": "",
        "HasEmbeddedLinks": "",
        "HasEmbeddedPhone": "",
        "HelpKeywords": "",
        "HelpMessage": "",
        "MessageFlow": "",
        "MessageSamples": "",
        "OptInKeywords": "",
        "OptInMessage": "",
        "OptOutKeywords": "",
        "OptOutMessage": "",
        "UsAppToPersonUsecase": ""
    });

    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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p \
  content-type:application/x-www-form-urlencoded \
  BrandRegistrationSid='' \
  Description='' \
  HasEmbeddedLinks='' \
  HasEmbeddedPhone='' \
  HelpKeywords='' \
  HelpMessage='' \
  MessageFlow='' \
  MessageSamples='' \
  OptInKeywords='' \
  OptInMessage='' \
  OptOutKeywords='' \
  OptOutMessage='' \
  UsAppToPersonUsecase=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'BrandRegistrationSid=&Description=&HasEmbeddedLinks=&HasEmbeddedPhone=&HelpKeywords=&HelpMessage=&MessageFlow=&MessageSamples=&OptInKeywords=&OptInMessage=&OptOutKeywords=&OptOutMessage=&UsAppToPersonUsecase=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p

import Foundation

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

let postData = NSMutableData(data: "BrandRegistrationSid=".data(using: String.Encoding.utf8)!)
postData.append("&Description=".data(using: String.Encoding.utf8)!)
postData.append("&HasEmbeddedLinks=".data(using: String.Encoding.utf8)!)
postData.append("&HasEmbeddedPhone=".data(using: String.Encoding.utf8)!)
postData.append("&HelpKeywords=".data(using: String.Encoding.utf8)!)
postData.append("&HelpMessage=".data(using: String.Encoding.utf8)!)
postData.append("&MessageFlow=".data(using: String.Encoding.utf8)!)
postData.append("&MessageSamples=".data(using: String.Encoding.utf8)!)
postData.append("&OptInKeywords=".data(using: String.Encoding.utf8)!)
postData.append("&OptInMessage=".data(using: String.Encoding.utf8)!)
postData.append("&OptOutKeywords=".data(using: String.Encoding.utf8)!)
postData.append("&OptOutMessage=".data(using: String.Encoding.utf8)!)
postData.append("&UsAppToPersonUsecase=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")! 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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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/v1/Services/:ServiceSid/AlphaSenders/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/AlphaSenders/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/LinkShortening/Domains/:DomainSid/Certificate");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

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

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

	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/v1/LinkShortening/Domains/:DomainSid/Certificate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .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}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate'
};

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate';
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}}/v1/LinkShortening/Domains/:DomainSid/Certificate',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

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}}/v1/LinkShortening/Domains/:DomainSid/Certificate'
};

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

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate';
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}}/v1/LinkShortening/Domains/:DomainSid/Certificate"]
                                                       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}}/v1/LinkShortening/Domains/:DomainSid/Certificate" in

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

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate",
  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}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/Certificate")

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

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

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")

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/v1/LinkShortening/Domains/:DomainSid/Certificate') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate";

    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}}/v1/LinkShortening/Domains/:DomainSid/Certificate

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")! 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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

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

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

	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/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"))
    .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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid'
};

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid';
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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid',
  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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');

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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid'
};

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

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid';
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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"]
                                                       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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid" in

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

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid",
  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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")

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

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

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")

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/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid";

    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}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/MessagingServices/:MessagingServiceSid")! 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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/v1/Services/:ServiceSid/PhoneNumbers/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/PhoneNumbers/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/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}}/v1/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}}/v1/Services/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/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/v1/Services/:Sid HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Services/:Sid'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/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/v1/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}}/v1/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}}/v1/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}}/v1/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}}/v1/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}}/v1/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}}/v1/Services/:Sid" in

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

 "{{baseUrl}}/v1/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}}/v1/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/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/v1/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}}/v1/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}}/v1/Services/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/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}}/v1/Services/:ServiceSid/ShortCodes/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/v1/Services/:ServiceSid/ShortCodes/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/ShortCodes/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid" in

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

 "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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/v1/Services/:ServiceSid/AlphaSenders/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/AlphaSenders/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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/v1/Services/:ServiceSid/AlphaSenders/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/Services/:ServiceSid/AlphaSenders/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders/: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}}/v1/a2p/BrandRegistrations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations/: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/v1/a2p/BrandRegistrations/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid'
};

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/a2p/BrandRegistrations/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/a2p/BrandRegistrations/: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/v1/a2p/BrandRegistrations/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations/: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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid"

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

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid"

	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/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid"))
    .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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")
  .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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid'
};

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid';
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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid',
  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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid');

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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid'
};

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

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid';
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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid"]
                                                       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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid",
  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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")

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/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings/:BrandVettingSid")! 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}}/v1/Deactivations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Deactivations")

require "http/client"

url = "{{baseUrl}}/v1/Deactivations"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Deactivations"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Deactivations"))
    .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}}/v1/Deactivations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Deactivations")
  .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}}/v1/Deactivations');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/v1/Deactivations';
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}}/v1/Deactivations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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}}/v1/Deactivations'};

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

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

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

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

 "{{baseUrl}}/v1/Deactivations",
  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}}/v1/Deactivations');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/Deactivations")

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

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

import requests

url = "{{baseUrl}}/v1/Deactivations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Deactivations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Deactivations")

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/v1/Deactivations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Deactivations

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Deactivations")! 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}}/v1/LinkShortening/Domains/:DomainSid/Certificate");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

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

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

	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/v1/LinkShortening/Domains/:DomainSid/Certificate HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"))
    .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}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .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}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate'
};

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate';
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}}/v1/LinkShortening/Domains/:DomainSid/Certificate',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/LinkShortening/Domains/:DomainSid/Certificate',
  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}}/v1/LinkShortening/Domains/:DomainSid/Certificate'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

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}}/v1/LinkShortening/Domains/:DomainSid/Certificate'
};

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

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate';
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}}/v1/LinkShortening/Domains/:DomainSid/Certificate"]
                                                       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}}/v1/LinkShortening/Domains/:DomainSid/Certificate" in

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

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate",
  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}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/Certificate")

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

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

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")

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/v1/LinkShortening/Domains/:DomainSid/Certificate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")! 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}}/v1/LinkShortening/Domains/:DomainSid/Config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

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

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

	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/v1/LinkShortening/Domains/:DomainSid/Config HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"))
    .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}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .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}}/v1/LinkShortening/Domains/:DomainSid/Config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config'
};

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config';
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}}/v1/LinkShortening/Domains/:DomainSid/Config',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/LinkShortening/Domains/:DomainSid/Config',
  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}}/v1/LinkShortening/Domains/:DomainSid/Config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');

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}}/v1/LinkShortening/Domains/:DomainSid/Config'
};

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

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

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config';
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}}/v1/LinkShortening/Domains/:DomainSid/Config"]
                                                       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}}/v1/LinkShortening/Domains/:DomainSid/Config" in

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

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config",
  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}}/v1/LinkShortening/Domains/:DomainSid/Config');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/Config")

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

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

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")

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/v1/LinkShortening/Domains/:DomainSid/Config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")! 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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig"

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

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig"

	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/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig"))
    .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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")
  .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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig'
};

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

const url = '{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig';
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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig',
  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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig');

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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig'
};

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

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

const url = '{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig';
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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig"]
                                                       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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig" in

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

 "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig",
  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}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")

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

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

import requests

url = "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")

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/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/MessagingService/:MessagingServiceSid/DomainConfig")! 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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/v1/Services/:ServiceSid/PhoneNumbers/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/PhoneNumbers/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/v1/Services/:ServiceSid/PhoneNumbers/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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}}/v1/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/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}}/v1/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}}/v1/Services/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/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/v1/Services/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/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}}/v1/Services/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/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}}/v1/Services/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

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

const url = '{{baseUrl}}/v1/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}}/v1/Services/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/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/v1/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}}/v1/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}}/v1/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}}/v1/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}}/v1/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}}/v1/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}}/v1/Services/:Sid" in

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

 "{{baseUrl}}/v1/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}}/v1/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/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/v1/Services/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/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}}/v1/Services/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/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}}/v1/Services/:ServiceSid/ShortCodes/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/v1/Services/:ServiceSid/ShortCodes/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/ShortCodes/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/v1/Services/:ServiceSid/ShortCodes/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Services/:ServiceSid/ShortCodes/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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}}/v1/Tollfree/Verifications/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Tollfree/Verifications/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Tollfree/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/v1/Tollfree/Verifications/:Sid HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Tollfree/Verifications/:Sid'
};

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

const url = '{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Tollfree/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/v1/Tollfree/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}}/v1/Tollfree/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}}/v1/Tollfree/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}}/v1/Tollfree/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}}/v1/Tollfree/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}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid" in

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

 "{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Tollfree/Verifications/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Tollfree/Verifications/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Tollfree/Verifications/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Tollfree/Verifications/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Tollfree/Verifications/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Tollfree/Verifications/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Tollfree/Verifications/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Tollfree/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/v1/Tollfree/Verifications/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Tollfree/Verifications/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Tollfree/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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid'
};

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

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

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid" in

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

 "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/: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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")

require "http/client"

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases"

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

var client = new RestClient("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases"

	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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases"))
    .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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")
  .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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases'
};

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

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases';
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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases',
  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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases');

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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases'
};

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

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

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases';
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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases"]
                                                       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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases" in

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

 "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases",
  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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")

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/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p/Usecases")! 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}}/v1/Services/Usecases");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/Usecases")

require "http/client"

url = "{{baseUrl}}/v1/Services/Usecases"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/Usecases"

	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/v1/Services/Usecases HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/Usecases"))
    .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}}/v1/Services/Usecases")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/Usecases")
  .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}}/v1/Services/Usecases');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/Usecases'};

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

const url = '{{baseUrl}}/v1/Services/Usecases';
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}}/v1/Services/Usecases',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/Usecases',
  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}}/v1/Services/Usecases'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/Usecases');

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}}/v1/Services/Usecases'};

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

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

const url = '{{baseUrl}}/v1/Services/Usecases';
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}}/v1/Services/Usecases"]
                                                       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}}/v1/Services/Usecases" in

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

 "{{baseUrl}}/v1/Services/Usecases",
  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}}/v1/Services/Usecases');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/Usecases');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/Usecases' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/Usecases' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/Usecases")

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

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

import requests

url = "{{baseUrl}}/v1/Services/Usecases"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/Usecases"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/Usecases")

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/v1/Services/Usecases') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/Usecases

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/Usecases

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

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

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

	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/v1/Services/:ServiceSid/AlphaSenders HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"))
    .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}}/v1/Services/:ServiceSid/AlphaSenders")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")
  .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}}/v1/Services/:ServiceSid/AlphaSenders');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders';
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}}/v1/Services/:ServiceSid/AlphaSenders',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ServiceSid/AlphaSenders',
  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}}/v1/Services/:ServiceSid/AlphaSenders'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders');

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}}/v1/Services/:ServiceSid/AlphaSenders'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders';
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}}/v1/Services/:ServiceSid/AlphaSenders"]
                                                       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}}/v1/Services/:ServiceSid/AlphaSenders" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders",
  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}}/v1/Services/:ServiceSid/AlphaSenders');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/AlphaSenders")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")

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/v1/Services/:ServiceSid/AlphaSenders') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/AlphaSenders")! 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}}/v1/a2p/BrandRegistrations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/a2p/BrandRegistrations")

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations"

	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/v1/a2p/BrandRegistrations HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations"))
    .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}}/v1/a2p/BrandRegistrations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/a2p/BrandRegistrations")
  .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}}/v1/a2p/BrandRegistrations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/a2p/BrandRegistrations'};

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations';
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}}/v1/a2p/BrandRegistrations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/a2p/BrandRegistrations',
  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}}/v1/a2p/BrandRegistrations'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/a2p/BrandRegistrations');

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}}/v1/a2p/BrandRegistrations'};

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

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations';
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}}/v1/a2p/BrandRegistrations"]
                                                       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}}/v1/a2p/BrandRegistrations" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations",
  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}}/v1/a2p/BrandRegistrations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/a2p/BrandRegistrations")

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/a2p/BrandRegistrations")

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/v1/a2p/BrandRegistrations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/a2p/BrandRegistrations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations")! 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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

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

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

	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/v1/a2p/BrandRegistrations/:BrandSid/Vettings HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"))
    .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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings'
};

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings';
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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/a2p/BrandRegistrations/:BrandSid/Vettings',
  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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');

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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings'
};

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

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

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings';
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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"]
                                                       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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings" in

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

 "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings",
  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}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/a2p/BrandRegistrations/:BrandSid/Vettings")

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

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

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")

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/v1/a2p/BrandRegistrations/:BrandSid/Vettings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations/:BrandSid/Vettings")! 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}}/v1/Services/:ServiceSid/PhoneNumbers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

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

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

	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/v1/Services/:ServiceSid/PhoneNumbers HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"))
    .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}}/v1/Services/:ServiceSid/PhoneNumbers")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")
  .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}}/v1/Services/:ServiceSid/PhoneNumbers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers';
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}}/v1/Services/:ServiceSid/PhoneNumbers',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ServiceSid/PhoneNumbers',
  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}}/v1/Services/:ServiceSid/PhoneNumbers'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers');

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}}/v1/Services/:ServiceSid/PhoneNumbers'
};

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

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers';
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}}/v1/Services/:ServiceSid/PhoneNumbers"]
                                                       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}}/v1/Services/:ServiceSid/PhoneNumbers" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers",
  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}}/v1/Services/:ServiceSid/PhoneNumbers');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/PhoneNumbers")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")

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/v1/Services/:ServiceSid/PhoneNumbers') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/v1/Services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/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/v1/Services HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/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}}/v1/Services")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/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}}/v1/Services');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/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}}/v1/Services',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/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}}/v1/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}}/v1/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}}/v1/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/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}}/v1/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}}/v1/Services" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/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}}/v1/Services');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/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/v1/Services') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/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}}/v1/Services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/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}}/v1/Services/:ServiceSid/ShortCodes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

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}}/v1/Services/:ServiceSid/ShortCodes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

	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/v1/Services/:ServiceSid/ShortCodes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"))
    .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}}/v1/Services/:ServiceSid/ShortCodes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")
  .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}}/v1/Services/:ServiceSid/ShortCodes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes';
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}}/v1/Services/:ServiceSid/ShortCodes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ServiceSid/ShortCodes',
  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}}/v1/Services/:ServiceSid/ShortCodes'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes');

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}}/v1/Services/:ServiceSid/ShortCodes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes';
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}}/v1/Services/:ServiceSid/ShortCodes"]
                                                       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}}/v1/Services/:ServiceSid/ShortCodes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes",
  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}}/v1/Services/:ServiceSid/ShortCodes');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/ShortCodes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")

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/v1/Services/:ServiceSid/ShortCodes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")! 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}}/v1/Tollfree/Verifications");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Tollfree/Verifications")

require "http/client"

url = "{{baseUrl}}/v1/Tollfree/Verifications"

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}}/v1/Tollfree/Verifications"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Tollfree/Verifications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Tollfree/Verifications"

	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/v1/Tollfree/Verifications HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Tollfree/Verifications")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Tollfree/Verifications"))
    .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}}/v1/Tollfree/Verifications")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Tollfree/Verifications")
  .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}}/v1/Tollfree/Verifications');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Tollfree/Verifications'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Tollfree/Verifications';
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}}/v1/Tollfree/Verifications',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Tollfree/Verifications")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Tollfree/Verifications',
  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}}/v1/Tollfree/Verifications'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Tollfree/Verifications');

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}}/v1/Tollfree/Verifications'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Tollfree/Verifications';
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}}/v1/Tollfree/Verifications"]
                                                       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}}/v1/Tollfree/Verifications" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Tollfree/Verifications",
  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}}/v1/Tollfree/Verifications');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Tollfree/Verifications');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Tollfree/Verifications');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Tollfree/Verifications' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Tollfree/Verifications' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Tollfree/Verifications")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Tollfree/Verifications"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Tollfree/Verifications"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Tollfree/Verifications")

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/v1/Tollfree/Verifications') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Tollfree/Verifications";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Tollfree/Verifications

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Tollfree/Verifications

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Tollfree/Verifications")! 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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")

require "http/client"

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

	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/v1/Services/:MessagingServiceSid/Compliance/Usa2p HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"))
    .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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p';
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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p',
  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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');

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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p';
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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"]
                                                       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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p",
  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}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:MessagingServiceSid/Compliance/Usa2p")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")

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/v1/Services/:MessagingServiceSid/Compliance/Usa2p') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:MessagingServiceSid/Compliance/Usa2p")! 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}}/v1/a2p/BrandRegistrations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/a2p/BrandRegistrations/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/a2p/BrandRegistrations/: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('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/a2p/BrandRegistrations/: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: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/: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: 'POST',
  url: '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/a2p/BrandRegistrations/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/a2p/BrandRegistrations/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/v1/a2p/BrandRegistrations/:Sid

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/a2p/BrandRegistrations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/a2p/BrandRegistrations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate");

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, "TlsCert=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate" {:form-params {:TlsCert ""}})

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "TlsCert="

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}}/v1/LinkShortening/Domains/:DomainSid/Certificate"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "TlsCert", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "TlsCert=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

	payload := strings.NewReader("TlsCert=")

	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/v1/LinkShortening/Domains/:DomainSid/Certificate HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 8

TlsCert=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("TlsCert=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("TlsCert="))
    .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, "TlsCert=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("TlsCert=")
  .asString();

const data = 'TlsCert=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('TlsCert', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate',
  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}}/v1/LinkShortening/Domains/:DomainSid/Certificate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({TlsCert: ''})
};

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}}/v1/LinkShortening/Domains/:DomainSid/Certificate',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    TlsCert: ''
  }
};

$.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, "TlsCert=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")
  .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/v1/LinkShortening/Domains/:DomainSid/Certificate',
  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({TlsCert: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {TlsCert: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  TlsCert: ''
});

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('TlsCert', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate',
  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('TlsCert', '');

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate';
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:[@"TlsCert=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"]
                                                       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}}/v1/LinkShortening/Domains/:DomainSid/Certificate" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "TlsCert=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "TlsCert=",
  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}}/v1/LinkShortening/Domains/:DomainSid/Certificate', [
  'form_params' => [
    'TlsCert' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'TlsCert' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'TlsCert' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate');
$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}}/v1/LinkShortening/Domains/:DomainSid/Certificate' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'TlsCert='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'TlsCert='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "TlsCert="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/Certificate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

payload = { "TlsCert": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate"

payload <- "TlsCert="

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}}/v1/LinkShortening/Domains/:DomainSid/Certificate")

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 = "TlsCert="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :TlsCert => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/LinkShortening/Domains/:DomainSid/Certificate') 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}}/v1/LinkShortening/Domains/:DomainSid/Certificate";

    let payload = json!({"TlsCert": ""});

    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}}/v1/LinkShortening/Domains/:DomainSid/Certificate \
  content-type:application/x-www-form-urlencoded \
  TlsCert=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data TlsCert= \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "TlsCert=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Certificate")! 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}}/v1/LinkShortening/Domains/:DomainSid/Config");

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, "CallbackUrl=&FallbackUrl=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config" {:form-params {:CallbackUrl ""
                                                                                                      :FallbackUrl ""}})

require "http/client"

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "CallbackUrl=&FallbackUrl="

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}}/v1/LinkShortening/Domains/:DomainSid/Config"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "CallbackUrl", "" },
        { "FallbackUrl", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "CallbackUrl=&FallbackUrl=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

	payload := strings.NewReader("CallbackUrl=&FallbackUrl=")

	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/v1/LinkShortening/Domains/:DomainSid/Config HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 25

CallbackUrl=&FallbackUrl=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("CallbackUrl=&FallbackUrl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("CallbackUrl=&FallbackUrl="))
    .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, "CallbackUrl=&FallbackUrl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("CallbackUrl=&FallbackUrl=")
  .asString();

const data = 'CallbackUrl=&FallbackUrl=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('CallbackUrl', '');
encodedParams.set('FallbackUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config',
  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}}/v1/LinkShortening/Domains/:DomainSid/Config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({CallbackUrl: '', FallbackUrl: ''})
};

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}}/v1/LinkShortening/Domains/:DomainSid/Config',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    CallbackUrl: '',
    FallbackUrl: ''
  }
};

$.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, "CallbackUrl=&FallbackUrl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")
  .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/v1/LinkShortening/Domains/:DomainSid/Config',
  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({CallbackUrl: '', FallbackUrl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {CallbackUrl: '', FallbackUrl: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  CallbackUrl: '',
  FallbackUrl: ''
});

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('CallbackUrl', '');
encodedParams.set('FallbackUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config',
  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('CallbackUrl', '');
encodedParams.set('FallbackUrl', '');

const url = '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config';
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:[@"CallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"]
                                                       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}}/v1/LinkShortening/Domains/:DomainSid/Config" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "CallbackUrl=&FallbackUrl=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "CallbackUrl=&FallbackUrl=",
  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}}/v1/LinkShortening/Domains/:DomainSid/Config', [
  'form_params' => [
    'CallbackUrl' => '',
    'FallbackUrl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'CallbackUrl' => '',
  'FallbackUrl' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'CallbackUrl' => '',
  'FallbackUrl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config');
$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}}/v1/LinkShortening/Domains/:DomainSid/Config' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CallbackUrl=&FallbackUrl='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'CallbackUrl=&FallbackUrl='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "CallbackUrl=&FallbackUrl="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/LinkShortening/Domains/:DomainSid/Config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

payload = {
    "CallbackUrl": "",
    "FallbackUrl": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config"

payload <- "CallbackUrl=&FallbackUrl="

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}}/v1/LinkShortening/Domains/:DomainSid/Config")

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 = "CallbackUrl=&FallbackUrl="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :CallbackUrl => "",
  :FallbackUrl => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/LinkShortening/Domains/:DomainSid/Config') 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}}/v1/LinkShortening/Domains/:DomainSid/Config";

    let payload = json!({
        "CallbackUrl": "",
        "FallbackUrl": ""
    });

    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}}/v1/LinkShortening/Domains/:DomainSid/Config \
  content-type:application/x-www-form-urlencoded \
  CallbackUrl='' \
  FallbackUrl=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'CallbackUrl=&FallbackUrl=' \
  --output-document \
  - {{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "CallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackUrl=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/LinkShortening/Domains/:DomainSid/Config")! 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}}/v1/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, "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:Sid" {:form-params {:AreaCodeGeomatch ""
                                                                           :FallbackMethod ""
                                                                           :FallbackToLongCode ""
                                                                           :FallbackUrl ""
                                                                           :FriendlyName ""
                                                                           :InboundMethod ""
                                                                           :InboundRequestUrl ""
                                                                           :MmsConverter ""
                                                                           :ScanMessageContent ""
                                                                           :SmartEncoding ""
                                                                           :StatusCallback ""
                                                                           :StickySender ""
                                                                           :SynchronousValidation ""
                                                                           :UseInboundWebhookOnNumber ""
                                                                           :Usecase ""
                                                                           :ValidityPeriod ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

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}}/v1/Services/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AreaCodeGeomatch", "" },
        { "FallbackMethod", "" },
        { "FallbackToLongCode", "" },
        { "FallbackUrl", "" },
        { "FriendlyName", "" },
        { "InboundMethod", "" },
        { "InboundRequestUrl", "" },
        { "MmsConverter", "" },
        { "ScanMessageContent", "" },
        { "SmartEncoding", "" },
        { "StatusCallback", "" },
        { "StickySender", "" },
        { "SynchronousValidation", "" },
        { "UseInboundWebhookOnNumber", "" },
        { "Usecase", "" },
        { "ValidityPeriod", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:Sid"

	payload := strings.NewReader("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")

	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/v1/Services/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 268

AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="))
    .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, "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")
  .asString();

const data = 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AreaCodeGeomatch', '');
encodedParams.set('FallbackMethod', '');
encodedParams.set('FallbackToLongCode', '');
encodedParams.set('FallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('InboundMethod', '');
encodedParams.set('InboundRequestUrl', '');
encodedParams.set('MmsConverter', '');
encodedParams.set('ScanMessageContent', '');
encodedParams.set('SmartEncoding', '');
encodedParams.set('StatusCallback', '');
encodedParams.set('StickySender', '');
encodedParams.set('SynchronousValidation', '');
encodedParams.set('UseInboundWebhookOnNumber', '');
encodedParams.set('Usecase', '');
encodedParams.set('ValidityPeriod', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/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}}/v1/Services/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AreaCodeGeomatch: '',
    FallbackMethod: '',
    FallbackToLongCode: '',
    FallbackUrl: '',
    FriendlyName: '',
    InboundMethod: '',
    InboundRequestUrl: '',
    MmsConverter: '',
    ScanMessageContent: '',
    SmartEncoding: '',
    StatusCallback: '',
    StickySender: '',
    SynchronousValidation: '',
    UseInboundWebhookOnNumber: '',
    Usecase: '',
    ValidityPeriod: ''
  })
};

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}}/v1/Services/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AreaCodeGeomatch: '',
    FallbackMethod: '',
    FallbackToLongCode: '',
    FallbackUrl: '',
    FriendlyName: '',
    InboundMethod: '',
    InboundRequestUrl: '',
    MmsConverter: '',
    ScanMessageContent: '',
    SmartEncoding: '',
    StatusCallback: '',
    StickySender: '',
    SynchronousValidation: '',
    UseInboundWebhookOnNumber: '',
    Usecase: '',
    ValidityPeriod: ''
  }
};

$.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, "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/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/v1/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({
  AreaCodeGeomatch: '',
  FallbackMethod: '',
  FallbackToLongCode: '',
  FallbackUrl: '',
  FriendlyName: '',
  InboundMethod: '',
  InboundRequestUrl: '',
  MmsConverter: '',
  ScanMessageContent: '',
  SmartEncoding: '',
  StatusCallback: '',
  StickySender: '',
  SynchronousValidation: '',
  UseInboundWebhookOnNumber: '',
  Usecase: '',
  ValidityPeriod: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AreaCodeGeomatch: '',
    FallbackMethod: '',
    FallbackToLongCode: '',
    FallbackUrl: '',
    FriendlyName: '',
    InboundMethod: '',
    InboundRequestUrl: '',
    MmsConverter: '',
    ScanMessageContent: '',
    SmartEncoding: '',
    StatusCallback: '',
    StickySender: '',
    SynchronousValidation: '',
    UseInboundWebhookOnNumber: '',
    Usecase: '',
    ValidityPeriod: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AreaCodeGeomatch: '',
  FallbackMethod: '',
  FallbackToLongCode: '',
  FallbackUrl: '',
  FriendlyName: '',
  InboundMethod: '',
  InboundRequestUrl: '',
  MmsConverter: '',
  ScanMessageContent: '',
  SmartEncoding: '',
  StatusCallback: '',
  StickySender: '',
  SynchronousValidation: '',
  UseInboundWebhookOnNumber: '',
  Usecase: '',
  ValidityPeriod: ''
});

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('AreaCodeGeomatch', '');
encodedParams.set('FallbackMethod', '');
encodedParams.set('FallbackToLongCode', '');
encodedParams.set('FallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('InboundMethod', '');
encodedParams.set('InboundRequestUrl', '');
encodedParams.set('MmsConverter', '');
encodedParams.set('ScanMessageContent', '');
encodedParams.set('SmartEncoding', '');
encodedParams.set('StatusCallback', '');
encodedParams.set('StickySender', '');
encodedParams.set('SynchronousValidation', '');
encodedParams.set('UseInboundWebhookOnNumber', '');
encodedParams.set('Usecase', '');
encodedParams.set('ValidityPeriod', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/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('AreaCodeGeomatch', '');
encodedParams.set('FallbackMethod', '');
encodedParams.set('FallbackToLongCode', '');
encodedParams.set('FallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('InboundMethod', '');
encodedParams.set('InboundRequestUrl', '');
encodedParams.set('MmsConverter', '');
encodedParams.set('ScanMessageContent', '');
encodedParams.set('SmartEncoding', '');
encodedParams.set('StatusCallback', '');
encodedParams.set('StickySender', '');
encodedParams.set('SynchronousValidation', '');
encodedParams.set('UseInboundWebhookOnNumber', '');
encodedParams.set('Usecase', '');
encodedParams.set('ValidityPeriod', '');

const url = '{{baseUrl}}/v1/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:[@"AreaCodeGeomatch=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackToLongCode=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&InboundMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&InboundRequestUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MmsConverter=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ScanMessageContent=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SmartEncoding=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&StatusCallback=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&StickySender=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SynchronousValidation=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UseInboundWebhookOnNumber=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Usecase=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ValidityPeriod=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/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}}/v1/Services/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/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 => "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=",
  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}}/v1/Services/:Sid', [
  'form_params' => [
    'AreaCodeGeomatch' => '',
    'FallbackMethod' => '',
    'FallbackToLongCode' => '',
    'FallbackUrl' => '',
    'FriendlyName' => '',
    'InboundMethod' => '',
    'InboundRequestUrl' => '',
    'MmsConverter' => '',
    'ScanMessageContent' => '',
    'SmartEncoding' => '',
    'StatusCallback' => '',
    'StickySender' => '',
    'SynchronousValidation' => '',
    'UseInboundWebhookOnNumber' => '',
    'Usecase' => '',
    'ValidityPeriod' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/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([
  'AreaCodeGeomatch' => '',
  'FallbackMethod' => '',
  'FallbackToLongCode' => '',
  'FallbackUrl' => '',
  'FriendlyName' => '',
  'InboundMethod' => '',
  'InboundRequestUrl' => '',
  'MmsConverter' => '',
  'ScanMessageContent' => '',
  'SmartEncoding' => '',
  'StatusCallback' => '',
  'StickySender' => '',
  'SynchronousValidation' => '',
  'UseInboundWebhookOnNumber' => '',
  'Usecase' => '',
  'ValidityPeriod' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AreaCodeGeomatch' => '',
  'FallbackMethod' => '',
  'FallbackToLongCode' => '',
  'FallbackUrl' => '',
  'FriendlyName' => '',
  'InboundMethod' => '',
  'InboundRequestUrl' => '',
  'MmsConverter' => '',
  'ScanMessageContent' => '',
  'SmartEncoding' => '',
  'StatusCallback' => '',
  'StickySender' => '',
  'SynchronousValidation' => '',
  'UseInboundWebhookOnNumber' => '',
  'Usecase' => '',
  'ValidityPeriod' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/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}}/v1/Services/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:Sid"

payload = {
    "AreaCodeGeomatch": "",
    "FallbackMethod": "",
    "FallbackToLongCode": "",
    "FallbackUrl": "",
    "FriendlyName": "",
    "InboundMethod": "",
    "InboundRequestUrl": "",
    "MmsConverter": "",
    "ScanMessageContent": "",
    "SmartEncoding": "",
    "StatusCallback": "",
    "StickySender": "",
    "SynchronousValidation": "",
    "UseInboundWebhookOnNumber": "",
    "Usecase": "",
    "ValidityPeriod": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:Sid"

payload <- "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

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}}/v1/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 = "AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AreaCodeGeomatch => "",
  :FallbackMethod => "",
  :FallbackToLongCode => "",
  :FallbackUrl => "",
  :FriendlyName => "",
  :InboundMethod => "",
  :InboundRequestUrl => "",
  :MmsConverter => "",
  :ScanMessageContent => "",
  :SmartEncoding => "",
  :StatusCallback => "",
  :StickySender => "",
  :SynchronousValidation => "",
  :UseInboundWebhookOnNumber => "",
  :Usecase => "",
  :ValidityPeriod => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/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}}/v1/Services/:Sid";

    let payload = json!({
        "AreaCodeGeomatch": "",
        "FallbackMethod": "",
        "FallbackToLongCode": "",
        "FallbackUrl": "",
        "FriendlyName": "",
        "InboundMethod": "",
        "InboundRequestUrl": "",
        "MmsConverter": "",
        "ScanMessageContent": "",
        "SmartEncoding": "",
        "StatusCallback": "",
        "StickySender": "",
        "SynchronousValidation": "",
        "UseInboundWebhookOnNumber": "",
        "Usecase": "",
        "ValidityPeriod": ""
    });

    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}}/v1/Services/:Sid \
  content-type:application/x-www-form-urlencoded \
  AreaCodeGeomatch='' \
  FallbackMethod='' \
  FallbackToLongCode='' \
  FallbackUrl='' \
  FriendlyName='' \
  InboundMethod='' \
  InboundRequestUrl='' \
  MmsConverter='' \
  ScanMessageContent='' \
  SmartEncoding='' \
  StatusCallback='' \
  StickySender='' \
  SynchronousValidation='' \
  UseInboundWebhookOnNumber='' \
  Usecase='' \
  ValidityPeriod=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AreaCodeGeomatch=&FallbackMethod=&FallbackToLongCode=&FallbackUrl=&FriendlyName=&InboundMethod=&InboundRequestUrl=&MmsConverter=&ScanMessageContent=&SmartEncoding=&StatusCallback=&StickySender=&SynchronousValidation=&UseInboundWebhookOnNumber=&Usecase=&ValidityPeriod=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AreaCodeGeomatch=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackMethod=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackToLongCode=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&InboundMethod=".data(using: String.Encoding.utf8)!)
postData.append("&InboundRequestUrl=".data(using: String.Encoding.utf8)!)
postData.append("&MmsConverter=".data(using: String.Encoding.utf8)!)
postData.append("&ScanMessageContent=".data(using: String.Encoding.utf8)!)
postData.append("&SmartEncoding=".data(using: String.Encoding.utf8)!)
postData.append("&StatusCallback=".data(using: String.Encoding.utf8)!)
postData.append("&StickySender=".data(using: String.Encoding.utf8)!)
postData.append("&SynchronousValidation=".data(using: String.Encoding.utf8)!)
postData.append("&UseInboundWebhookOnNumber=".data(using: String.Encoding.utf8)!)
postData.append("&Usecase=".data(using: String.Encoding.utf8)!)
postData.append("&ValidityPeriod=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/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}}/v1/Tollfree/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, "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Tollfree/Verifications/:Sid" {:form-params {:AdditionalInformation ""
                                                                                         :BusinessCity ""
                                                                                         :BusinessContactEmail ""
                                                                                         :BusinessContactFirstName ""
                                                                                         :BusinessContactLastName ""
                                                                                         :BusinessContactPhone ""
                                                                                         :BusinessCountry ""
                                                                                         :BusinessName ""
                                                                                         :BusinessPostalCode ""
                                                                                         :BusinessStateProvinceRegion ""
                                                                                         :BusinessStreetAddress ""
                                                                                         :BusinessStreetAddress2 ""
                                                                                         :BusinessWebsite ""
                                                                                         :MessageVolume ""
                                                                                         :NotificationEmail ""
                                                                                         :OptInImageUrls ""
                                                                                         :OptInType ""
                                                                                         :ProductionMessageSample ""
                                                                                         :UseCaseCategories ""
                                                                                         :UseCaseSummary ""}})

require "http/client"

url = "{{baseUrl}}/v1/Tollfree/Verifications/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary="

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}}/v1/Tollfree/Verifications/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AdditionalInformation", "" },
        { "BusinessCity", "" },
        { "BusinessContactEmail", "" },
        { "BusinessContactFirstName", "" },
        { "BusinessContactLastName", "" },
        { "BusinessContactPhone", "" },
        { "BusinessCountry", "" },
        { "BusinessName", "" },
        { "BusinessPostalCode", "" },
        { "BusinessStateProvinceRegion", "" },
        { "BusinessStreetAddress", "" },
        { "BusinessStreetAddress2", "" },
        { "BusinessWebsite", "" },
        { "MessageVolume", "" },
        { "NotificationEmail", "" },
        { "OptInImageUrls", "" },
        { "OptInType", "" },
        { "ProductionMessageSample", "" },
        { "UseCaseCategories", "" },
        { "UseCaseSummary", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Tollfree/Verifications/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Tollfree/Verifications/:Sid"

	payload := strings.NewReader("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=")

	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/v1/Tollfree/Verifications/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 396

AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Tollfree/Verifications/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Tollfree/Verifications/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary="))
    .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, "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Tollfree/Verifications/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Tollfree/Verifications/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=")
  .asString();

const data = 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Tollfree/Verifications/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AdditionalInformation', '');
encodedParams.set('BusinessCity', '');
encodedParams.set('BusinessContactEmail', '');
encodedParams.set('BusinessContactFirstName', '');
encodedParams.set('BusinessContactLastName', '');
encodedParams.set('BusinessContactPhone', '');
encodedParams.set('BusinessCountry', '');
encodedParams.set('BusinessName', '');
encodedParams.set('BusinessPostalCode', '');
encodedParams.set('BusinessStateProvinceRegion', '');
encodedParams.set('BusinessStreetAddress', '');
encodedParams.set('BusinessStreetAddress2', '');
encodedParams.set('BusinessWebsite', '');
encodedParams.set('MessageVolume', '');
encodedParams.set('NotificationEmail', '');
encodedParams.set('OptInImageUrls', '');
encodedParams.set('OptInType', '');
encodedParams.set('ProductionMessageSample', '');
encodedParams.set('UseCaseCategories', '');
encodedParams.set('UseCaseSummary', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AdditionalInformation: '',
    BusinessCity: '',
    BusinessContactEmail: '',
    BusinessContactFirstName: '',
    BusinessContactLastName: '',
    BusinessContactPhone: '',
    BusinessCountry: '',
    BusinessName: '',
    BusinessPostalCode: '',
    BusinessStateProvinceRegion: '',
    BusinessStreetAddress: '',
    BusinessStreetAddress2: '',
    BusinessWebsite: '',
    MessageVolume: '',
    NotificationEmail: '',
    OptInImageUrls: '',
    OptInType: '',
    ProductionMessageSample: '',
    UseCaseCategories: '',
    UseCaseSummary: ''
  })
};

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}}/v1/Tollfree/Verifications/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AdditionalInformation: '',
    BusinessCity: '',
    BusinessContactEmail: '',
    BusinessContactFirstName: '',
    BusinessContactLastName: '',
    BusinessContactPhone: '',
    BusinessCountry: '',
    BusinessName: '',
    BusinessPostalCode: '',
    BusinessStateProvinceRegion: '',
    BusinessStreetAddress: '',
    BusinessStreetAddress2: '',
    BusinessWebsite: '',
    MessageVolume: '',
    NotificationEmail: '',
    OptInImageUrls: '',
    OptInType: '',
    ProductionMessageSample: '',
    UseCaseCategories: '',
    UseCaseSummary: ''
  }
};

$.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, "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Tollfree/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/v1/Tollfree/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({
  AdditionalInformation: '',
  BusinessCity: '',
  BusinessContactEmail: '',
  BusinessContactFirstName: '',
  BusinessContactLastName: '',
  BusinessContactPhone: '',
  BusinessCountry: '',
  BusinessName: '',
  BusinessPostalCode: '',
  BusinessStateProvinceRegion: '',
  BusinessStreetAddress: '',
  BusinessStreetAddress2: '',
  BusinessWebsite: '',
  MessageVolume: '',
  NotificationEmail: '',
  OptInImageUrls: '',
  OptInType: '',
  ProductionMessageSample: '',
  UseCaseCategories: '',
  UseCaseSummary: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Tollfree/Verifications/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AdditionalInformation: '',
    BusinessCity: '',
    BusinessContactEmail: '',
    BusinessContactFirstName: '',
    BusinessContactLastName: '',
    BusinessContactPhone: '',
    BusinessCountry: '',
    BusinessName: '',
    BusinessPostalCode: '',
    BusinessStateProvinceRegion: '',
    BusinessStreetAddress: '',
    BusinessStreetAddress2: '',
    BusinessWebsite: '',
    MessageVolume: '',
    NotificationEmail: '',
    OptInImageUrls: '',
    OptInType: '',
    ProductionMessageSample: '',
    UseCaseCategories: '',
    UseCaseSummary: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Tollfree/Verifications/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AdditionalInformation: '',
  BusinessCity: '',
  BusinessContactEmail: '',
  BusinessContactFirstName: '',
  BusinessContactLastName: '',
  BusinessContactPhone: '',
  BusinessCountry: '',
  BusinessName: '',
  BusinessPostalCode: '',
  BusinessStateProvinceRegion: '',
  BusinessStreetAddress: '',
  BusinessStreetAddress2: '',
  BusinessWebsite: '',
  MessageVolume: '',
  NotificationEmail: '',
  OptInImageUrls: '',
  OptInType: '',
  ProductionMessageSample: '',
  UseCaseCategories: '',
  UseCaseSummary: ''
});

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('AdditionalInformation', '');
encodedParams.set('BusinessCity', '');
encodedParams.set('BusinessContactEmail', '');
encodedParams.set('BusinessContactFirstName', '');
encodedParams.set('BusinessContactLastName', '');
encodedParams.set('BusinessContactPhone', '');
encodedParams.set('BusinessCountry', '');
encodedParams.set('BusinessName', '');
encodedParams.set('BusinessPostalCode', '');
encodedParams.set('BusinessStateProvinceRegion', '');
encodedParams.set('BusinessStreetAddress', '');
encodedParams.set('BusinessStreetAddress2', '');
encodedParams.set('BusinessWebsite', '');
encodedParams.set('MessageVolume', '');
encodedParams.set('NotificationEmail', '');
encodedParams.set('OptInImageUrls', '');
encodedParams.set('OptInType', '');
encodedParams.set('ProductionMessageSample', '');
encodedParams.set('UseCaseCategories', '');
encodedParams.set('UseCaseSummary', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Tollfree/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('AdditionalInformation', '');
encodedParams.set('BusinessCity', '');
encodedParams.set('BusinessContactEmail', '');
encodedParams.set('BusinessContactFirstName', '');
encodedParams.set('BusinessContactLastName', '');
encodedParams.set('BusinessContactPhone', '');
encodedParams.set('BusinessCountry', '');
encodedParams.set('BusinessName', '');
encodedParams.set('BusinessPostalCode', '');
encodedParams.set('BusinessStateProvinceRegion', '');
encodedParams.set('BusinessStreetAddress', '');
encodedParams.set('BusinessStreetAddress2', '');
encodedParams.set('BusinessWebsite', '');
encodedParams.set('MessageVolume', '');
encodedParams.set('NotificationEmail', '');
encodedParams.set('OptInImageUrls', '');
encodedParams.set('OptInType', '');
encodedParams.set('ProductionMessageSample', '');
encodedParams.set('UseCaseCategories', '');
encodedParams.set('UseCaseSummary', '');

const url = '{{baseUrl}}/v1/Tollfree/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:[@"AdditionalInformation=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessCity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactEmail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactFirstName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactLastName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessContactPhone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessCountry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessPostalCode=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessStateProvinceRegion=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessStreetAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessStreetAddress2=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&BusinessWebsite=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessageVolume=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NotificationEmail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptInImageUrls=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OptInType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ProductionMessageSample=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UseCaseCategories=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UseCaseSummary=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Tollfree/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 => "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=",
  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}}/v1/Tollfree/Verifications/:Sid', [
  'form_params' => [
    'AdditionalInformation' => '',
    'BusinessCity' => '',
    'BusinessContactEmail' => '',
    'BusinessContactFirstName' => '',
    'BusinessContactLastName' => '',
    'BusinessContactPhone' => '',
    'BusinessCountry' => '',
    'BusinessName' => '',
    'BusinessPostalCode' => '',
    'BusinessStateProvinceRegion' => '',
    'BusinessStreetAddress' => '',
    'BusinessStreetAddress2' => '',
    'BusinessWebsite' => '',
    'MessageVolume' => '',
    'NotificationEmail' => '',
    'OptInImageUrls' => '',
    'OptInType' => '',
    'ProductionMessageSample' => '',
    'UseCaseCategories' => '',
    'UseCaseSummary' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Tollfree/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([
  'AdditionalInformation' => '',
  'BusinessCity' => '',
  'BusinessContactEmail' => '',
  'BusinessContactFirstName' => '',
  'BusinessContactLastName' => '',
  'BusinessContactPhone' => '',
  'BusinessCountry' => '',
  'BusinessName' => '',
  'BusinessPostalCode' => '',
  'BusinessStateProvinceRegion' => '',
  'BusinessStreetAddress' => '',
  'BusinessStreetAddress2' => '',
  'BusinessWebsite' => '',
  'MessageVolume' => '',
  'NotificationEmail' => '',
  'OptInImageUrls' => '',
  'OptInType' => '',
  'ProductionMessageSample' => '',
  'UseCaseCategories' => '',
  'UseCaseSummary' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AdditionalInformation' => '',
  'BusinessCity' => '',
  'BusinessContactEmail' => '',
  'BusinessContactFirstName' => '',
  'BusinessContactLastName' => '',
  'BusinessContactPhone' => '',
  'BusinessCountry' => '',
  'BusinessName' => '',
  'BusinessPostalCode' => '',
  'BusinessStateProvinceRegion' => '',
  'BusinessStreetAddress' => '',
  'BusinessStreetAddress2' => '',
  'BusinessWebsite' => '',
  'MessageVolume' => '',
  'NotificationEmail' => '',
  'OptInImageUrls' => '',
  'OptInType' => '',
  'ProductionMessageSample' => '',
  'UseCaseCategories' => '',
  'UseCaseSummary' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Tollfree/Verifications/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Tollfree/Verifications/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Tollfree/Verifications/:Sid"

payload = {
    "AdditionalInformation": "",
    "BusinessCity": "",
    "BusinessContactEmail": "",
    "BusinessContactFirstName": "",
    "BusinessContactLastName": "",
    "BusinessContactPhone": "",
    "BusinessCountry": "",
    "BusinessName": "",
    "BusinessPostalCode": "",
    "BusinessStateProvinceRegion": "",
    "BusinessStreetAddress": "",
    "BusinessStreetAddress2": "",
    "BusinessWebsite": "",
    "MessageVolume": "",
    "NotificationEmail": "",
    "OptInImageUrls": "",
    "OptInType": "",
    "ProductionMessageSample": "",
    "UseCaseCategories": "",
    "UseCaseSummary": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Tollfree/Verifications/:Sid"

payload <- "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary="

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}}/v1/Tollfree/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 = "AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AdditionalInformation => "",
  :BusinessCity => "",
  :BusinessContactEmail => "",
  :BusinessContactFirstName => "",
  :BusinessContactLastName => "",
  :BusinessContactPhone => "",
  :BusinessCountry => "",
  :BusinessName => "",
  :BusinessPostalCode => "",
  :BusinessStateProvinceRegion => "",
  :BusinessStreetAddress => "",
  :BusinessStreetAddress2 => "",
  :BusinessWebsite => "",
  :MessageVolume => "",
  :NotificationEmail => "",
  :OptInImageUrls => "",
  :OptInType => "",
  :ProductionMessageSample => "",
  :UseCaseCategories => "",
  :UseCaseSummary => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Tollfree/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}}/v1/Tollfree/Verifications/:Sid";

    let payload = json!({
        "AdditionalInformation": "",
        "BusinessCity": "",
        "BusinessContactEmail": "",
        "BusinessContactFirstName": "",
        "BusinessContactLastName": "",
        "BusinessContactPhone": "",
        "BusinessCountry": "",
        "BusinessName": "",
        "BusinessPostalCode": "",
        "BusinessStateProvinceRegion": "",
        "BusinessStreetAddress": "",
        "BusinessStreetAddress2": "",
        "BusinessWebsite": "",
        "MessageVolume": "",
        "NotificationEmail": "",
        "OptInImageUrls": "",
        "OptInType": "",
        "ProductionMessageSample": "",
        "UseCaseCategories": "",
        "UseCaseSummary": ""
    });

    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}}/v1/Tollfree/Verifications/:Sid \
  content-type:application/x-www-form-urlencoded \
  AdditionalInformation='' \
  BusinessCity='' \
  BusinessContactEmail='' \
  BusinessContactFirstName='' \
  BusinessContactLastName='' \
  BusinessContactPhone='' \
  BusinessCountry='' \
  BusinessName='' \
  BusinessPostalCode='' \
  BusinessStateProvinceRegion='' \
  BusinessStreetAddress='' \
  BusinessStreetAddress2='' \
  BusinessWebsite='' \
  MessageVolume='' \
  NotificationEmail='' \
  OptInImageUrls='' \
  OptInType='' \
  ProductionMessageSample='' \
  UseCaseCategories='' \
  UseCaseSummary=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AdditionalInformation=&BusinessCity=&BusinessContactEmail=&BusinessContactFirstName=&BusinessContactLastName=&BusinessContactPhone=&BusinessCountry=&BusinessName=&BusinessPostalCode=&BusinessStateProvinceRegion=&BusinessStreetAddress=&BusinessStreetAddress2=&BusinessWebsite=&MessageVolume=&NotificationEmail=&OptInImageUrls=&OptInType=&ProductionMessageSample=&UseCaseCategories=&UseCaseSummary=' \
  --output-document \
  - {{baseUrl}}/v1/Tollfree/Verifications/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AdditionalInformation=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessCity=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactEmail=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactFirstName=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactLastName=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessContactPhone=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessCountry=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessName=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessPostalCode=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessStateProvinceRegion=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessStreetAddress=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessStreetAddress2=".data(using: String.Encoding.utf8)!)
postData.append("&BusinessWebsite=".data(using: String.Encoding.utf8)!)
postData.append("&MessageVolume=".data(using: String.Encoding.utf8)!)
postData.append("&NotificationEmail=".data(using: String.Encoding.utf8)!)
postData.append("&OptInImageUrls=".data(using: String.Encoding.utf8)!)
postData.append("&OptInType=".data(using: String.Encoding.utf8)!)
postData.append("&ProductionMessageSample=".data(using: String.Encoding.utf8)!)
postData.append("&UseCaseCategories=".data(using: String.Encoding.utf8)!)
postData.append("&UseCaseSummary=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Tollfree/Verifications/: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()