POST CreateMessageInteraction
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions
QUERY PARAMS
ServiceSid
SessionSid
ParticipantSid
BODY formUrlEncoded
Body
MediaUrl
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions");

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, "Body=&MediaUrl=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions" {:form-params {:Body ""
                                                                                                                                                        :MediaUrl ""}})
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Body=&MediaUrl="

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Body", "" },
        { "MediaUrl", "" },
    }),
};
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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Body=&MediaUrl=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

	payload := strings.NewReader("Body=&MediaUrl=")

	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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 15

Body=&MediaUrl=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Body=&MediaUrl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Body=&MediaUrl="))
    .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, "Body=&MediaUrl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Body=&MediaUrl=")
  .asString();
const data = 'Body=&MediaUrl=';

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

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

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

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Body: '',
    MediaUrl: ''
  }
};

$.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, "Body=&MediaUrl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions',
  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({Body: '', MediaUrl: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Body: '', MediaUrl: ''}
};

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');

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

req.form({
  Body: '',
  MediaUrl: ''
});

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions',
  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('Body', '');
encodedParams.set('MediaUrl', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions';
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:[@"Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MediaUrl=" dataUsingEncoding:NSUTF8StringEncoding]];

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Body=&MediaUrl=",
  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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions', [
  'form_params' => [
    'Body' => '',
    'MediaUrl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'Body' => '',
  'MediaUrl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');
$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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Body=&MediaUrl='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Body=&MediaUrl='
import http.client

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

payload = "Body=&MediaUrl="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions", payload, headers)

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

payload = {
    "Body": "",
    "MediaUrl": ""
}
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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

payload <- "Body=&MediaUrl="

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")

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 = "Body=&MediaUrl="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :Body => "",
  :MediaUrl => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions') 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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions";

    let payload = json!({
        "Body": "",
        "MediaUrl": ""
    });

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

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Body= \
  --data MediaUrl=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions \
  content-type:application/x-www-form-urlencoded \
  Body='' \
  MediaUrl=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Body=&MediaUrl=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")! 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()
POST CreateParticipant
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants
QUERY PARAMS
ServiceSid
SessionSid
BODY formUrlEncoded
FriendlyName
Identifier
ProxyIdentifier
ProxyIdentifierSid
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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, "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants" {:form-params {:FriendlyName ""
                                                                                                                    :Identifier ""
                                                                                                                    :ProxyIdentifier ""
                                                                                                                    :ProxyIdentifierSid ""}})
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid="

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/Sessions/:SessionSid/Participants"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FriendlyName", "" },
        { "Identifier", "" },
        { "ProxyIdentifier", "" },
        { "ProxyIdentifierSid", "" },
    }),
};
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/Sessions/:SessionSid/Participants");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"

	payload := strings.NewReader("FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=")

	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/Sessions/:SessionSid/Participants HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 62

FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid="))
    .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, "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")
  .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/Sessions/:SessionSid/Participants")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=")
  .asString();
const data = 'FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=';

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/Sessions/:SessionSid/Participants');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Identifier', '');
encodedParams.set('ProxyIdentifier', '');
encodedParams.set('ProxyIdentifierSid', '');

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

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/Sessions/:SessionSid/Participants',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FriendlyName: '',
    Identifier: '',
    ProxyIdentifier: '',
    ProxyIdentifierSid: ''
  }
};

$.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, "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")
  .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/Sessions/:SessionSid/Participants',
  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({FriendlyName: '', Identifier: '', ProxyIdentifier: '', ProxyIdentifierSid: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {FriendlyName: '', Identifier: '', ProxyIdentifier: '', ProxyIdentifierSid: ''}
};

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/Sessions/:SessionSid/Participants');

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

req.form({
  FriendlyName: '',
  Identifier: '',
  ProxyIdentifier: '',
  ProxyIdentifierSid: ''
});

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('FriendlyName', '');
encodedParams.set('Identifier', '');
encodedParams.set('ProxyIdentifier', '');
encodedParams.set('ProxyIdentifierSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants',
  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('FriendlyName', '');
encodedParams.set('Identifier', '');
encodedParams.set('ProxyIdentifier', '');
encodedParams.set('ProxyIdentifierSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants';
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:[@"FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identifier=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ProxyIdentifier=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ProxyIdentifierSid=" dataUsingEncoding:NSUTF8StringEncoding]];

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=",
  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/Sessions/:SessionSid/Participants', [
  'form_params' => [
    'FriendlyName' => '',
    'Identifier' => '',
    'ProxyIdentifier' => '',
    'ProxyIdentifierSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'FriendlyName' => '',
  'Identifier' => '',
  'ProxyIdentifier' => '',
  'ProxyIdentifierSid' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'FriendlyName' => '',
  'Identifier' => '',
  'ProxyIdentifier' => '',
  'ProxyIdentifierSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants');
$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/Sessions/:SessionSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid='
import http.client

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

payload = "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid="

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

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

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"

payload = {
    "FriendlyName": "",
    "Identifier": "",
    "ProxyIdentifier": "",
    "ProxyIdentifierSid": ""
}
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/Sessions/:SessionSid/Participants"

payload <- "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid="

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/Sessions/:SessionSid/Participants")

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 = "FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :FriendlyName => "",
  :Identifier => "",
  :ProxyIdentifier => "",
  :ProxyIdentifierSid => "",
}

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

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

    let payload = json!({
        "FriendlyName": "",
        "Identifier": "",
        "ProxyIdentifier": "",
        "ProxyIdentifierSid": ""
    });

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

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data FriendlyName= \
  --data Identifier= \
  --data ProxyIdentifier= \
  --data ProxyIdentifierSid=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants \
  content-type:application/x-www-form-urlencoded \
  FriendlyName='' \
  Identifier='' \
  ProxyIdentifier='' \
  ProxyIdentifierSid=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'FriendlyName=&Identifier=&ProxyIdentifier=&ProxyIdentifierSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants
import Foundation

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

let postData = NSMutableData(data: "FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Identifier=".data(using: String.Encoding.utf8)!)
postData.append("&ProxyIdentifier=".data(using: String.Encoding.utf8)!)
postData.append("&ProxyIdentifierSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")! 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()
POST CreatePhoneNumber
{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers
QUERY PARAMS
ServiceSid
BODY formUrlEncoded
IsReserved
PhoneNumber
Sid
Examples
REQUEST
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, "IsReserved=&PhoneNumber=&Sid=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers" {:form-params {:IsReserved ""
                                                                                               :PhoneNumber ""
                                                                                               :Sid ""}})
require "http/client"

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

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
    {
        { "IsReserved", "" },
        { "PhoneNumber", "" },
        { "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");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "IsReserved=&PhoneNumber=&Sid=", 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("IsReserved=&PhoneNumber=&Sid=")

	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: 29

IsReserved=&PhoneNumber=&Sid=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("IsReserved=&PhoneNumber=&Sid=")
  .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("IsReserved=&PhoneNumber=&Sid="))
    .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, "IsReserved=&PhoneNumber=&Sid=");
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("IsReserved=&PhoneNumber=&Sid=")
  .asString();
const data = 'IsReserved=&PhoneNumber=&Sid=';

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('IsReserved', '');
encodedParams.set('PhoneNumber', '');
encodedParams.set('Sid', '');

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({IsReserved: '', PhoneNumber: '', Sid: ''})
};

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: {
    IsReserved: '',
    PhoneNumber: '',
    Sid: ''
  }
};

$.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, "IsReserved=&PhoneNumber=&Sid=")
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({IsReserved: '', PhoneNumber: '', Sid: ''}));
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: {IsReserved: '', PhoneNumber: '', 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/Services/:ServiceSid/PhoneNumbers');

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

req.form({
  IsReserved: '',
  PhoneNumber: '',
  Sid: ''
});

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('IsReserved', '');
encodedParams.set('PhoneNumber', '');
encodedParams.set('Sid', '');

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('IsReserved', '');
encodedParams.set('PhoneNumber', '');
encodedParams.set('Sid', '');

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:[@"IsReserved=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PhoneNumber=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Sid=" 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 "IsReserved=&PhoneNumber=&Sid=" 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 => "IsReserved=&PhoneNumber=&Sid=",
  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' => [
    'IsReserved' => '',
    'PhoneNumber' => '',
    'Sid' => ''
  ],
  '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([
  'IsReserved' => '',
  'PhoneNumber' => '',
  'Sid' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'IsReserved' => '',
  'PhoneNumber' => '',
  'Sid' => ''
]));

$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 'IsReserved=&PhoneNumber=&Sid='
$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 'IsReserved=&PhoneNumber=&Sid='
import http.client

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

payload = "IsReserved=&PhoneNumber=&Sid="

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 = {
    "IsReserved": "",
    "PhoneNumber": "",
    "Sid": ""
}
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 <- "IsReserved=&PhoneNumber=&Sid="

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 = "IsReserved=&PhoneNumber=&Sid="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :IsReserved => "",
  :PhoneNumber => "",
  :Sid => "",
}

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!({
        "IsReserved": "",
        "PhoneNumber": "",
        "Sid": ""
    });

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

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data IsReserved= \
  --data PhoneNumber= \
  --data Sid=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers \
  content-type:application/x-www-form-urlencoded \
  IsReserved='' \
  PhoneNumber='' \
  Sid=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'IsReserved=&PhoneNumber=&Sid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers
import Foundation

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

let postData = NSMutableData(data: "IsReserved=".data(using: String.Encoding.utf8)!)
postData.append("&PhoneNumber=".data(using: String.Encoding.utf8)!)
postData.append("&Sid=".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()
POST CreateService
{{baseUrl}}/v1/Services
BODY formUrlEncoded
CallbackUrl
ChatInstanceSid
DefaultTtl
GeoMatchLevel
InterceptCallbackUrl
NumberSelectionBehavior
OutOfSessionCallbackUrl
UniqueName
Examples
REQUEST
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, "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services" {:form-params {:CallbackUrl ""
                                                                      :ChatInstanceSid ""
                                                                      :DefaultTtl ""
                                                                      :GeoMatchLevel ""
                                                                      :InterceptCallbackUrl ""
                                                                      :NumberSelectionBehavior ""
                                                                      :OutOfSessionCallbackUrl ""
                                                                      :UniqueName ""}})
require "http/client"

url = "{{baseUrl}}/v1/Services"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "CallbackUrl", "" },
        { "ChatInstanceSid", "" },
        { "DefaultTtl", "" },
        { "GeoMatchLevel", "" },
        { "InterceptCallbackUrl", "" },
        { "NumberSelectionBehavior", "" },
        { "OutOfSessionCallbackUrl", "" },
        { "UniqueName", "" },
    }),
};
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", "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

	payload := strings.NewReader("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")

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

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

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

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

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

}
POST /baseUrl/v1/Services HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 140

CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")
  .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("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=");
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("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")
  .asString();
const data = 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services');
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('ChatInstanceSid', '');
encodedParams.set('DefaultTtl', '');
encodedParams.set('GeoMatchLevel', '');
encodedParams.set('InterceptCallbackUrl', '');
encodedParams.set('NumberSelectionBehavior', '');
encodedParams.set('OutOfSessionCallbackUrl', '');
encodedParams.set('UniqueName', '');

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({
    CallbackUrl: '',
    ChatInstanceSid: '',
    DefaultTtl: '',
    GeoMatchLevel: '',
    InterceptCallbackUrl: '',
    NumberSelectionBehavior: '',
    OutOfSessionCallbackUrl: '',
    UniqueName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    CallbackUrl: '',
    ChatInstanceSid: '',
    DefaultTtl: '',
    GeoMatchLevel: '',
    InterceptCallbackUrl: '',
    NumberSelectionBehavior: '',
    OutOfSessionCallbackUrl: '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")
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({
  CallbackUrl: '',
  ChatInstanceSid: '',
  DefaultTtl: '',
  GeoMatchLevel: '',
  InterceptCallbackUrl: '',
  NumberSelectionBehavior: '',
  OutOfSessionCallbackUrl: '',
  UniqueName: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    CallbackUrl: '',
    ChatInstanceSid: '',
    DefaultTtl: '',
    GeoMatchLevel: '',
    InterceptCallbackUrl: '',
    NumberSelectionBehavior: '',
    OutOfSessionCallbackUrl: '',
    UniqueName: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.form({
  CallbackUrl: '',
  ChatInstanceSid: '',
  DefaultTtl: '',
  GeoMatchLevel: '',
  InterceptCallbackUrl: '',
  NumberSelectionBehavior: '',
  OutOfSessionCallbackUrl: '',
  UniqueName: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('CallbackUrl', '');
encodedParams.set('ChatInstanceSid', '');
encodedParams.set('DefaultTtl', '');
encodedParams.set('GeoMatchLevel', '');
encodedParams.set('InterceptCallbackUrl', '');
encodedParams.set('NumberSelectionBehavior', '');
encodedParams.set('OutOfSessionCallbackUrl', '');
encodedParams.set('UniqueName', '');

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('CallbackUrl', '');
encodedParams.set('ChatInstanceSid', '');
encodedParams.set('DefaultTtl', '');
encodedParams.set('GeoMatchLevel', '');
encodedParams.set('InterceptCallbackUrl', '');
encodedParams.set('NumberSelectionBehavior', '');
encodedParams.set('OutOfSessionCallbackUrl', '');
encodedParams.set('UniqueName', '');

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:[@"CallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatInstanceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultTtl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&GeoMatchLevel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&InterceptCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NumberSelectionBehavior=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OutOfSessionCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" 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 "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=" 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 => "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/Services', [
  'form_params' => [
    'CallbackUrl' => '',
    'ChatInstanceSid' => '',
    'DefaultTtl' => '',
    'GeoMatchLevel' => '',
    'InterceptCallbackUrl' => '',
    'NumberSelectionBehavior' => '',
    'OutOfSessionCallbackUrl' => '',
    'UniqueName' => ''
  ],
  '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([
  'CallbackUrl' => '',
  'ChatInstanceSid' => '',
  'DefaultTtl' => '',
  'GeoMatchLevel' => '',
  'InterceptCallbackUrl' => '',
  'NumberSelectionBehavior' => '',
  'OutOfSessionCallbackUrl' => '',
  'UniqueName' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'CallbackUrl' => '',
  'ChatInstanceSid' => '',
  'DefaultTtl' => '',
  'GeoMatchLevel' => '',
  'InterceptCallbackUrl' => '',
  'NumberSelectionBehavior' => '',
  'OutOfSessionCallbackUrl' => '',
  'UniqueName' => ''
]));

$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 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName='
$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 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName='
import http.client

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

payload = "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

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 = {
    "CallbackUrl": "",
    "ChatInstanceSid": "",
    "DefaultTtl": "",
    "GeoMatchLevel": "",
    "InterceptCallbackUrl": "",
    "NumberSelectionBehavior": "",
    "OutOfSessionCallbackUrl": "",
    "UniqueName": ""
}
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 <- "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

encode <- "form"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/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 = "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :CallbackUrl => "",
  :ChatInstanceSid => "",
  :DefaultTtl => "",
  :GeoMatchLevel => "",
  :InterceptCallbackUrl => "",
  :NumberSelectionBehavior => "",
  :OutOfSessionCallbackUrl => "",
  :UniqueName => "",
}

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!({
        "CallbackUrl": "",
        "ChatInstanceSid": "",
        "DefaultTtl": "",
        "GeoMatchLevel": "",
        "InterceptCallbackUrl": "",
        "NumberSelectionBehavior": "",
        "OutOfSessionCallbackUrl": "",
        "UniqueName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data CallbackUrl= \
  --data ChatInstanceSid= \
  --data DefaultTtl= \
  --data GeoMatchLevel= \
  --data InterceptCallbackUrl= \
  --data NumberSelectionBehavior= \
  --data OutOfSessionCallbackUrl= \
  --data UniqueName=
http --form POST {{baseUrl}}/v1/Services \
  content-type:application/x-www-form-urlencoded \
  CallbackUrl='' \
  ChatInstanceSid='' \
  DefaultTtl='' \
  GeoMatchLevel='' \
  InterceptCallbackUrl='' \
  NumberSelectionBehavior='' \
  OutOfSessionCallbackUrl='' \
  UniqueName=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services
import Foundation

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

let postData = NSMutableData(data: "CallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&ChatInstanceSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultTtl=".data(using: String.Encoding.utf8)!)
postData.append("&GeoMatchLevel=".data(using: String.Encoding.utf8)!)
postData.append("&InterceptCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&NumberSelectionBehavior=".data(using: String.Encoding.utf8)!)
postData.append("&OutOfSessionCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".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()
POST CreateSession
{{baseUrl}}/v1/Services/:ServiceSid/Sessions
QUERY PARAMS
ServiceSid
BODY formUrlEncoded
DateExpiry
Mode
Participants
Status
Ttl
UniqueName
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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, "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Sessions" {:form-params {:DateExpiry ""
                                                                                           :Mode ""
                                                                                           :Participants ""
                                                                                           :Status ""
                                                                                           :Ttl ""
                                                                                           :UniqueName ""}})
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ServiceSid/Sessions"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "DateExpiry", "" },
        { "Mode", "" },
        { "Participants", "" },
        { "Status", "" },
        { "Ttl", "" },
        { "UniqueName", "" },
    }),
};
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/Sessions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

	payload := strings.NewReader("DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=")

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

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

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

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

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

}
POST /baseUrl/v1/Services/:ServiceSid/Sessions HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 56

DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions")
  .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/Sessions")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=")
  .asString();
const data = 'DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=';

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

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

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

xhr.send(data);
import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('DateExpiry', '');
encodedParams.set('Mode', '');
encodedParams.set('Participants', '');
encodedParams.set('Status', '');
encodedParams.set('Ttl', '');
encodedParams.set('UniqueName', '');

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

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    DateExpiry: '',
    Mode: '',
    Participants: '',
    Status: '',
    Ttl: '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions")
  .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/Sessions',
  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({
  DateExpiry: '',
  Mode: '',
  Participants: '',
  Status: '',
  Ttl: '',
  UniqueName: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    DateExpiry: '',
    Mode: '',
    Participants: '',
    Status: '',
    Ttl: '',
    UniqueName: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.form({
  DateExpiry: '',
  Mode: '',
  Participants: '',
  Status: '',
  Ttl: '',
  UniqueName: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('DateExpiry', '');
encodedParams.set('Mode', '');
encodedParams.set('Participants', '');
encodedParams.set('Status', '');
encodedParams.set('Ttl', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions',
  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('DateExpiry', '');
encodedParams.set('Mode', '');
encodedParams.set('Participants', '');
encodedParams.set('Status', '');
encodedParams.set('Ttl', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions';
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:[@"DateExpiry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Mode=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Participants=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Status=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Ttl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Sessions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ServiceSid/Sessions" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/Services/:ServiceSid/Sessions', [
  'form_params' => [
    'DateExpiry' => '',
    'Mode' => '',
    'Participants' => '',
    'Status' => '',
    'Ttl' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'DateExpiry' => '',
  'Mode' => '',
  'Participants' => '',
  'Status' => '',
  'Ttl' => '',
  'UniqueName' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'DateExpiry' => '',
  'Mode' => '',
  'Participants' => '',
  'Status' => '',
  'Ttl' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions');
$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/Sessions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName='
import http.client

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

payload = "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName="

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

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

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

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

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

payload = {
    "DateExpiry": "",
    "Mode": "",
    "Participants": "",
    "Status": "",
    "Ttl": "",
    "UniqueName": ""
}
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/Sessions"

payload <- "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName="

encode <- "form"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions")

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 = "DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :DateExpiry => "",
  :Mode => "",
  :Participants => "",
  :Status => "",
  :Ttl => "",
  :UniqueName => "",
}

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

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

    let payload = json!({
        "DateExpiry": "",
        "Mode": "",
        "Participants": "",
        "Status": "",
        "Ttl": "",
        "UniqueName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data DateExpiry= \
  --data Mode= \
  --data Participants= \
  --data Status= \
  --data Ttl= \
  --data UniqueName=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Sessions \
  content-type:application/x-www-form-urlencoded \
  DateExpiry='' \
  Mode='' \
  Participants='' \
  Status='' \
  Ttl='' \
  UniqueName=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'DateExpiry=&Mode=&Participants=&Status=&Ttl=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions
import Foundation

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

let postData = NSMutableData(data: "DateExpiry=".data(using: String.Encoding.utf8)!)
postData.append("&Mode=".data(using: String.Encoding.utf8)!)
postData.append("&Participants=".data(using: String.Encoding.utf8)!)
postData.append("&Status=".data(using: String.Encoding.utf8)!)
postData.append("&Ttl=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()
POST CreateShortCode
{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes
QUERY PARAMS
ServiceSid
BODY formUrlEncoded
Sid
Examples
REQUEST
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, "Sid=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

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

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

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
    {
        { "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");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Sid=", 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("Sid=")

	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: 4

Sid=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Sid=")
  .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("Sid="))
    .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, "Sid=");
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("Sid=")
  .asString();
const data = 'Sid=';

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

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({Sid: ''})
};

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: {
    Sid: ''
  }
};

$.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, "Sid=")
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({Sid: ''}));
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: {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/Services/:ServiceSid/ShortCodes');

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

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

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

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

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:[@"Sid=" 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 "Sid=" 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 => "Sid=",
  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' => [
    'Sid' => ''
  ],
  '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([
  'Sid' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'Sid' => ''
]));

$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 'Sid='
$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 'Sid='
import http.client

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

payload = "Sid="

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 = { "Sid": "" }
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 <- "Sid="

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

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :Sid => "",
}

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!({"Sid": ""});

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

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Sid=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes \
  content-type:application/x-www-form-urlencoded \
  Sid=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Sid= \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes
import Foundation

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

let postData = NSMutableData(data: "Sid=".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()
DELETE DeleteInteraction
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
QUERY PARAMS
ServiceSid
SessionSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid")
require "http/client"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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()
DELETE DeleteParticipant
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
QUERY PARAMS
ServiceSid
SessionSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid")
require "http/client"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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()
DELETE DeletePhoneNumber
{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid
QUERY PARAMS
ServiceSid
Sid
Examples
REQUEST
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);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid
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()
DELETE DeleteService
{{baseUrl}}/v1/Services/:Sid
QUERY PARAMS
Sid
Examples
REQUEST
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);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:Sid
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()
DELETE DeleteSession
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
QUERY PARAMS
ServiceSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid")
require "http/client"

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


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

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

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

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/Sessions/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/Sessions/:Sid');

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid' -Method DELETE 
import http.client

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

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

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

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

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

response = requests.delete(url)

print(response.json())
library(httr)

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

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

content(response, "text")
require 'uri'
require 'net/http'

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

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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()
DELETE DeleteShortCode
{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid
QUERY PARAMS
ServiceSid
Sid
Examples
REQUEST
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);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid
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()
GET FetchInteraction
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
QUERY PARAMS
ServiceSid
SessionSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid")
require "http/client"

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


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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/Sessions/:SessionSid/Interactions/:Sid') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions/: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()
GET FetchMessageInteraction
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid
QUERY PARAMS
ServiceSid
SessionSid
ParticipantSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid")
require "http/client"

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


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions/: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()
GET FetchParticipant
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
QUERY PARAMS
ServiceSid
SessionSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid")
require "http/client"

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


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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/Sessions/:SessionSid/Participants/:Sid') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/: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()
GET FetchPhoneNumber
{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid
QUERY PARAMS
ServiceSid
Sid
Examples
REQUEST
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);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid
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()
GET FetchService
{{baseUrl}}/v1/Services/:Sid
QUERY PARAMS
Sid
Examples
REQUEST
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);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:Sid
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()
GET FetchSession
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
QUERY PARAMS
ServiceSid
Sid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid")
require "http/client"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/Sessions/:Sid');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/Sessions/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/Sessions/:Sid');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:Sid")

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

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

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

response = requests.get(url)

print(response.json())
library(httr)

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

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/Sessions/:Sid') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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()
GET FetchShortCode
{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid
QUERY PARAMS
ServiceSid
Sid
Examples
REQUEST
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);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid
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()
GET ListInteraction
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions
QUERY PARAMS
ServiceSid
SessionSid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions")
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions"

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/Sessions/:SessionSid/Interactions"),
};
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/Sessions/:SessionSid/Interactions");
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/Sessions/:SessionSid/Interactions"

	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/Sessions/:SessionSid/Interactions HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions"))
    .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/Sessions/:SessionSid/Interactions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions")
  .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/Sessions/:SessionSid/Interactions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions';
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/Sessions/:SessionSid/Interactions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

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/Sessions/:SessionSid/Interactions');

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/Sessions/:SessionSid/Interactions'
};

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/Sessions/:SessionSid/Interactions';
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/Sessions/:SessionSid/Interactions"]
                                                       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/Sessions/:SessionSid/Interactions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions",
  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/Sessions/:SessionSid/Interactions');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions")

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/Sessions/:SessionSid/Interactions') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Interactions")! 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()
GET ListMessageInteraction
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions
QUERY PARAMS
ServiceSid
SessionSid
ParticipantSid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"),
};
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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions");
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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

	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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"))
    .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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions';
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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")
  .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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions',
  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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions'
};

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions'
};

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions';
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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"]
                                                       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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions",
  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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")

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/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants/:ParticipantSid/MessageInteractions")! 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()
GET ListParticipant
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants
QUERY PARAMS
ServiceSid
SessionSid
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"

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/Sessions/:SessionSid/Participants"),
};
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/Sessions/:SessionSid/Participants");
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/Sessions/:SessionSid/Participants"

	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/Sessions/:SessionSid/Participants HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"))
    .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/Sessions/:SessionSid/Participants")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")
  .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/Sessions/:SessionSid/Participants');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants';
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/Sessions/:SessionSid/Participants',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

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/Sessions/:SessionSid/Participants');

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/Sessions/:SessionSid/Participants'
};

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/Sessions/:SessionSid/Participants';
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/Sessions/:SessionSid/Participants"]
                                                       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/Sessions/:SessionSid/Participants" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants",
  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/Sessions/:SessionSid/Participants');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")

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

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

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")

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/Sessions/:SessionSid/Participants') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:SessionSid/Participants")! 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()
GET ListPhoneNumber
{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers
QUERY PARAMS
ServiceSid
Examples
REQUEST
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);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers
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()
GET ListService
{{baseUrl}}/v1/Services
Examples
REQUEST
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);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services
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()
GET ListSession
{{baseUrl}}/v1/Services/:ServiceSid/Sessions
QUERY PARAMS
ServiceSid
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Sessions")
require "http/client"

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

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

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


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions"))
    .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/Sessions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Sessions")
  .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/Sessions');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions';
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/Sessions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

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/Sessions');

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/Sessions'
};

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/Sessions';
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/Sessions"]
                                                       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/Sessions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions",
  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/Sessions');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Sessions")

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

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

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

response = requests.get(url)

print(response.json())
library(httr)

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

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions")

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/Sessions') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions
http GET {{baseUrl}}/v1/Services/:ServiceSid/Sessions
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions")! 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()
GET ListShortCode
{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes
QUERY PARAMS
ServiceSid
Examples
REQUEST
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);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes
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()
POST UpdatePhoneNumber
{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid
QUERY PARAMS
ServiceSid
Sid
BODY formUrlEncoded
IsReserved
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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, "IsReserved=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid" {:form-params {:IsReserved ""}})
require "http/client"

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

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/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "IsReserved", "" },
    }),
};
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.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "IsReserved=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

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

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

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("IsReserved="))
    .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, "IsReserved=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/:ServiceSid/PhoneNumbers/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("IsReserved=")
  .asString();
const data = 'IsReserved=';

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/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

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

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

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: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    IsReserved: ''
  }
};

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

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

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/:Sid');

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

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

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

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

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

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

Client.call ~headers ~body `POST 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 => "POST",
  CURLOPT_POSTFIELDS => "IsReserved=",
  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/:Sid', [
  'form_params' => [
    'IsReserved' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

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

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'IsReserved' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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/:ServiceSid/PhoneNumbers/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'IsReserved='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'IsReserved='
import http.client

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

payload = "IsReserved="

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

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

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

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

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

payload = { "IsReserved": "" }
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/:Sid"

payload <- "IsReserved="

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/: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 = "IsReserved="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :IsReserved => "",
}

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

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

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

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

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data IsReserved=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid \
  content-type:application/x-www-form-urlencoded \
  IsReserved=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data IsReserved= \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/:Sid
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/PhoneNumbers/: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()
POST UpdateService
{{baseUrl}}/v1/Services/:Sid
QUERY PARAMS
Sid
BODY formUrlEncoded
CallbackUrl
ChatInstanceSid
DefaultTtl
GeoMatchLevel
InterceptCallbackUrl
NumberSelectionBehavior
OutOfSessionCallbackUrl
UniqueName
Examples
REQUEST
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, "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:Sid" {:form-params {:CallbackUrl ""
                                                                           :ChatInstanceSid ""
                                                                           :DefaultTtl ""
                                                                           :GeoMatchLevel ""
                                                                           :InterceptCallbackUrl ""
                                                                           :NumberSelectionBehavior ""
                                                                           :OutOfSessionCallbackUrl ""
                                                                           :UniqueName ""}})
require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "CallbackUrl", "" },
        { "ChatInstanceSid", "" },
        { "DefaultTtl", "" },
        { "GeoMatchLevel", "" },
        { "InterceptCallbackUrl", "" },
        { "NumberSelectionBehavior", "" },
        { "OutOfSessionCallbackUrl", "" },
        { "UniqueName", "" },
    }),
};
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", "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=", 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("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")

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

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

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

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

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

}
POST /baseUrl/v1/Services/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 140

CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")
  .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("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=");
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("CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")
  .asString();
const data = 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=';

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

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

xhr.open('POST', '{{baseUrl}}/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('CallbackUrl', '');
encodedParams.set('ChatInstanceSid', '');
encodedParams.set('DefaultTtl', '');
encodedParams.set('GeoMatchLevel', '');
encodedParams.set('InterceptCallbackUrl', '');
encodedParams.set('NumberSelectionBehavior', '');
encodedParams.set('OutOfSessionCallbackUrl', '');
encodedParams.set('UniqueName', '');

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({
    CallbackUrl: '',
    ChatInstanceSid: '',
    DefaultTtl: '',
    GeoMatchLevel: '',
    InterceptCallbackUrl: '',
    NumberSelectionBehavior: '',
    OutOfSessionCallbackUrl: '',
    UniqueName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    CallbackUrl: '',
    ChatInstanceSid: '',
    DefaultTtl: '',
    GeoMatchLevel: '',
    InterceptCallbackUrl: '',
    NumberSelectionBehavior: '',
    OutOfSessionCallbackUrl: '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=")
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({
  CallbackUrl: '',
  ChatInstanceSid: '',
  DefaultTtl: '',
  GeoMatchLevel: '',
  InterceptCallbackUrl: '',
  NumberSelectionBehavior: '',
  OutOfSessionCallbackUrl: '',
  UniqueName: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    CallbackUrl: '',
    ChatInstanceSid: '',
    DefaultTtl: '',
    GeoMatchLevel: '',
    InterceptCallbackUrl: '',
    NumberSelectionBehavior: '',
    OutOfSessionCallbackUrl: '',
    UniqueName: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.form({
  CallbackUrl: '',
  ChatInstanceSid: '',
  DefaultTtl: '',
  GeoMatchLevel: '',
  InterceptCallbackUrl: '',
  NumberSelectionBehavior: '',
  OutOfSessionCallbackUrl: '',
  UniqueName: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('CallbackUrl', '');
encodedParams.set('ChatInstanceSid', '');
encodedParams.set('DefaultTtl', '');
encodedParams.set('GeoMatchLevel', '');
encodedParams.set('InterceptCallbackUrl', '');
encodedParams.set('NumberSelectionBehavior', '');
encodedParams.set('OutOfSessionCallbackUrl', '');
encodedParams.set('UniqueName', '');

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('CallbackUrl', '');
encodedParams.set('ChatInstanceSid', '');
encodedParams.set('DefaultTtl', '');
encodedParams.set('GeoMatchLevel', '');
encodedParams.set('InterceptCallbackUrl', '');
encodedParams.set('NumberSelectionBehavior', '');
encodedParams.set('OutOfSessionCallbackUrl', '');
encodedParams.set('UniqueName', '');

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:[@"CallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatInstanceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultTtl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&GeoMatchLevel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&InterceptCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NumberSelectionBehavior=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&OutOfSessionCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" 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 "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=" 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 => "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/Services/:Sid', [
  'form_params' => [
    'CallbackUrl' => '',
    'ChatInstanceSid' => '',
    'DefaultTtl' => '',
    'GeoMatchLevel' => '',
    'InterceptCallbackUrl' => '',
    'NumberSelectionBehavior' => '',
    'OutOfSessionCallbackUrl' => '',
    'UniqueName' => ''
  ],
  '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([
  'CallbackUrl' => '',
  'ChatInstanceSid' => '',
  'DefaultTtl' => '',
  'GeoMatchLevel' => '',
  'InterceptCallbackUrl' => '',
  'NumberSelectionBehavior' => '',
  'OutOfSessionCallbackUrl' => '',
  'UniqueName' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'CallbackUrl' => '',
  'ChatInstanceSid' => '',
  'DefaultTtl' => '',
  'GeoMatchLevel' => '',
  'InterceptCallbackUrl' => '',
  'NumberSelectionBehavior' => '',
  'OutOfSessionCallbackUrl' => '',
  'UniqueName' => ''
]));

$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 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName='
$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 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName='
import http.client

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

payload = "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

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 = {
    "CallbackUrl": "",
    "ChatInstanceSid": "",
    "DefaultTtl": "",
    "GeoMatchLevel": "",
    "InterceptCallbackUrl": "",
    "NumberSelectionBehavior": "",
    "OutOfSessionCallbackUrl": "",
    "UniqueName": ""
}
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 <- "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

encode <- "form"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/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 = "CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :CallbackUrl => "",
  :ChatInstanceSid => "",
  :DefaultTtl => "",
  :GeoMatchLevel => "",
  :InterceptCallbackUrl => "",
  :NumberSelectionBehavior => "",
  :OutOfSessionCallbackUrl => "",
  :UniqueName => "",
}

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!({
        "CallbackUrl": "",
        "ChatInstanceSid": "",
        "DefaultTtl": "",
        "GeoMatchLevel": "",
        "InterceptCallbackUrl": "",
        "NumberSelectionBehavior": "",
        "OutOfSessionCallbackUrl": "",
        "UniqueName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data CallbackUrl= \
  --data ChatInstanceSid= \
  --data DefaultTtl= \
  --data GeoMatchLevel= \
  --data InterceptCallbackUrl= \
  --data NumberSelectionBehavior= \
  --data OutOfSessionCallbackUrl= \
  --data UniqueName=
http --form POST {{baseUrl}}/v1/Services/:Sid \
  content-type:application/x-www-form-urlencoded \
  CallbackUrl='' \
  ChatInstanceSid='' \
  DefaultTtl='' \
  GeoMatchLevel='' \
  InterceptCallbackUrl='' \
  NumberSelectionBehavior='' \
  OutOfSessionCallbackUrl='' \
  UniqueName=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'CallbackUrl=&ChatInstanceSid=&DefaultTtl=&GeoMatchLevel=&InterceptCallbackUrl=&NumberSelectionBehavior=&OutOfSessionCallbackUrl=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid
import Foundation

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

let postData = NSMutableData(data: "CallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&ChatInstanceSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultTtl=".data(using: String.Encoding.utf8)!)
postData.append("&GeoMatchLevel=".data(using: String.Encoding.utf8)!)
postData.append("&InterceptCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&NumberSelectionBehavior=".data(using: String.Encoding.utf8)!)
postData.append("&OutOfSessionCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".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()
POST UpdateSession
{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
QUERY PARAMS
ServiceSid
Sid
BODY formUrlEncoded
DateExpiry
Status
Ttl
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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, "DateExpiry=&Status=&Ttl=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid" {:form-params {:DateExpiry ""
                                                                                                :Status ""
                                                                                                :Ttl ""}})
require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "DateExpiry=&Status=&Ttl="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "DateExpiry", "" },
        { "Status", "" },
        { "Ttl", "" },
    }),
};
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/Sessions/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "DateExpiry=&Status=&Ttl=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

	payload := strings.NewReader("DateExpiry=&Status=&Ttl=")

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

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

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

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

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

}
POST /baseUrl/v1/Services/:ServiceSid/Sessions/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 24

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("DateExpiry=&Status=&Ttl="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "DateExpiry=&Status=&Ttl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/:ServiceSid/Sessions/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("DateExpiry=&Status=&Ttl=")
  .asString();
const data = 'DateExpiry=&Status=&Ttl=';

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

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

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

xhr.send(data);
import axios from 'axios';

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

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

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    DateExpiry: '',
    Status: '',
    Ttl: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "DateExpiry=&Status=&Ttl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/:ServiceSid/Sessions/: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({DateExpiry: '', Status: '', Ttl: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {DateExpiry: '', Status: '', Ttl: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.form({
  DateExpiry: '',
  Status: '',
  Ttl: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;
const { URLSearchParams } = require('url');

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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('DateExpiry', '');
encodedParams.set('Status', '');
encodedParams.set('Ttl', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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:[@"DateExpiry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Status=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Ttl=" dataUsingEncoding:NSUTF8StringEncoding]];

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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 => "DateExpiry=&Status=&Ttl=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid', [
  'form_params' => [
    'DateExpiry' => '',
    'Status' => '',
    'Ttl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'DateExpiry' => '',
  'Status' => '',
  'Ttl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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/:ServiceSid/Sessions/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DateExpiry=&Status=&Ttl='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DateExpiry=&Status=&Ttl='
import http.client

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

payload = "DateExpiry=&Status=&Ttl="

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

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

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

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

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

payload = {
    "DateExpiry": "",
    "Status": "",
    "Ttl": ""
}
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/Sessions/:Sid"

payload <- "DateExpiry=&Status=&Ttl="

encode <- "form"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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 = "DateExpiry=&Status=&Ttl="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :DateExpiry => "",
  :Status => "",
  :Ttl => "",
}

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

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

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data DateExpiry= \
  --data Status= \
  --data Ttl=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid \
  content-type:application/x-www-form-urlencoded \
  DateExpiry='' \
  Status='' \
  Ttl=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'DateExpiry=&Status=&Ttl=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Sessions/:Sid
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Sessions/: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()
POST UpdateShortCode
{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid
QUERY PARAMS
ServiceSid
Sid
BODY formUrlEncoded
IsReserved
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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, "IsReserved=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid" {:form-params {:IsReserved ""}})
require "http/client"

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

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/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "IsReserved", "" },
    }),
};
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.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "IsReserved=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

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

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

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("IsReserved="))
    .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, "IsReserved=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/:ServiceSid/ShortCodes/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("IsReserved=")
  .asString();
const data = 'IsReserved=';

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/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

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

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

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: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    IsReserved: ''
  }
};

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

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

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/:Sid');

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

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

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

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

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

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

Client.call ~headers ~body `POST 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 => "POST",
  CURLOPT_POSTFIELDS => "IsReserved=",
  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/:Sid', [
  'form_params' => [
    'IsReserved' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

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

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'IsReserved' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/: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/:ServiceSid/ShortCodes/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'IsReserved='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'IsReserved='
import http.client

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

payload = "IsReserved="

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

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

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

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

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

payload = { "IsReserved": "" }
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/:Sid"

payload <- "IsReserved="

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/: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 = "IsReserved="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :IsReserved => "",
}

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

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

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

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

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data IsReserved=
http --form POST {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid \
  content-type:application/x-www-form-urlencoded \
  IsReserved=''
wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data IsReserved= \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/ShortCodes/:Sid
import Foundation

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

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

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