CURL *hnd = curl_easy_init();

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

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, "Attributes=&FriendlyName=&Type=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels" {:form-params {:Attributes ""
                                                                                           :FriendlyName ""
                                                                                           :Type ""
                                                                                           :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&Type=&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/Channels"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "Type", "" },
        { "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/Channels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&Type=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("Attributes=&FriendlyName=&Type=&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/Channels HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 43

Attributes=&FriendlyName=&Type=&UniqueName=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&Type=&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, "Attributes=&FriendlyName=&Type=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .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/Channels")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&Type=&UniqueName=")
  .asString();

const data = 'Attributes=&FriendlyName=&Type=&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/Channels');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Type', '');
encodedParams.set('UniqueName', '');

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

const request = require('request');

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

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

req.form({
  Attributes: '',
  FriendlyName: '',
  Type: '',
  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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Type', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels',
  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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Type', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels';
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:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ServiceSid/Channels" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&Type=&UniqueName=" in

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

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

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'Type' => '',
  'UniqueName' => ''
]));

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

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

import http.client

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

payload = "Attributes=&FriendlyName=&Type=&UniqueName="

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

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

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

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

import requests

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

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "Type": "",
    "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/Channels"

payload <- "Attributes=&FriendlyName=&Type=&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/Channels")

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 = "Attributes=&FriendlyName=&Type=&UniqueName="

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

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :Type => "",
  :UniqueName => "",
}

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

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

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "Type": "",
        "UniqueName": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  Type='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&Type=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels

import Foundation

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

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Credentials" {:form-params {:ApiKey ""
                                                                         :Certificate ""
                                                                         :FriendlyName ""
                                                                         :PrivateKey ""
                                                                         :Sandbox ""
                                                                         :Secret ""
                                                                         :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Credentials"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

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/Credentials"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ApiKey", "" },
        { "Certificate", "" },
        { "FriendlyName", "" },
        { "PrivateKey", "" },
        { "Sandbox", "" },
        { "Secret", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")

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

ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Credentials")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="))
    .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, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Credentials")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
  .asString();

const data = 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=';

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

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

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials',
  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/Credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  })
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Credentials',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  }
};

$.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, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .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/Credentials',
  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({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: '',
  Type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  }
};

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

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

req.form({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: '',
  Type: ''
});

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('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials',
  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('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const url = '{{baseUrl}}/v1/Credentials';
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:[@"ApiKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Certificate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PrivateKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Sandbox=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Secret=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Credentials" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=" in

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

 "{{baseUrl}}/v1/Credentials",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=",
  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/Credentials', [
  'form_params' => [
    'ApiKey' => '',
    'Certificate' => '',
    'FriendlyName' => '',
    'PrivateKey' => '',
    'Sandbox' => '',
    'Secret' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => '',
  'Type' => ''
]);

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

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

append(new http\QueryString([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => '',
  'Type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Credentials');
$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/Credentials' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type='

import http.client

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

payload = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

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

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

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

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

import requests

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

payload = {
    "ApiKey": "",
    "Certificate": "",
    "FriendlyName": "",
    "PrivateKey": "",
    "Sandbox": "",
    "Secret": "",
    "Type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

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

payload <- "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

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/Credentials")

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 = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

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

require 'faraday'

data = {
  :ApiKey => "",
  :Certificate => "",
  :FriendlyName => "",
  :PrivateKey => "",
  :Sandbox => "",
  :Secret => "",
  :Type => "",
}

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

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

    let payload = json!({
        "ApiKey": "",
        "Certificate": "",
        "FriendlyName": "",
        "PrivateKey": "",
        "Sandbox": "",
        "Secret": "",
        "Type": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Credentials \
  content-type:application/x-www-form-urlencoded \
  ApiKey='' \
  Certificate='' \
  FriendlyName='' \
  PrivateKey='' \
  Sandbox='' \
  Secret='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Credentials

import Foundation

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

let postData = NSMutableData(data: "ApiKey=".data(using: String.Encoding.utf8)!)
postData.append("&Certificate=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&PrivateKey=".data(using: String.Encoding.utf8)!)
postData.append("&Sandbox=".data(using: String.Encoding.utf8)!)
postData.append("&Secret=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites" {:form-params {:Identity ""
                                                                                                               :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Identity=&RoleSid="

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/Channels/:ChannelSid/Invites"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Identity", "" },
        { "RoleSid", "" },
    }),
};
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/Channels/:ChannelSid/Invites");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

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

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

Identity=&RoleSid=

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/Channels/:ChannelSid/Invites")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Identity=&RoleSid=")
  .asString();

const data = 'Identity=&RoleSid=';

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

xhr.send(data);

import axios from 'axios';

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

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

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/Channels/:ChannelSid/Invites',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Identity: '',
    RoleSid: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Identity=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/Channels/:ChannelSid/Invites',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Identity: '', RoleSid: ''}
};

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/Channels/:ChannelSid/Invites');

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

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

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

import http.client

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

payload = "Identity=&RoleSid="

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

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

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

payload = {
    "Identity": "",
    "RoleSid": ""
}
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/Channels/:ChannelSid/Invites"

payload <- "Identity=&RoleSid="

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/Channels/:ChannelSid/Invites")

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

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

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

require 'faraday'

data = {
  :Identity => "",
  :RoleSid => "",
}

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

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

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites \
  content-type:application/x-www-form-urlencoded \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members" {:form-params {:Identity ""
                                                                                                               :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Identity=&RoleSid="

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/Channels/:ChannelSid/Members"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Identity", "" },
        { "RoleSid", "" },
    }),
};
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/Channels/:ChannelSid/Members");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

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

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

Identity=&RoleSid=

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/Channels/:ChannelSid/Members")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Identity=&RoleSid=")
  .asString();

const data = 'Identity=&RoleSid=';

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

xhr.send(data);

import axios from 'axios';

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

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

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/Channels/:ChannelSid/Members',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Identity: '',
    RoleSid: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Identity=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/Channels/:ChannelSid/Members',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Identity: '', RoleSid: ''}
};

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/Channels/:ChannelSid/Members');

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

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

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

import http.client

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

payload = "Identity=&RoleSid="

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

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

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

payload = {
    "Identity": "",
    "RoleSid": ""
}
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/Channels/:ChannelSid/Members"

payload <- "Identity=&RoleSid="

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/Channels/:ChannelSid/Members")

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

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

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

require 'faraday'

data = {
  :Identity => "",
  :RoleSid => "",
}

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

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

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members \
  content-type:application/x-www-form-urlencoded \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages" {:form-params {:Attributes ""
                                                                                                                :Body ""
                                                                                                                :From ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Body=&From="

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/Channels/:ChannelSid/Messages"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Body", "" },
        { "From", "" },
    }),
};
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/Channels/:ChannelSid/Messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Body=&From=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

	payload := strings.NewReader("Attributes=&Body=&From=")

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

Attributes=&Body=&From=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Body=&From="))
    .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, "Attributes=&Body=&From=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")
  .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/Channels/:ChannelSid/Messages")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Body=&From=")
  .asString();

const data = 'Attributes=&Body=&From=';

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

xhr.send(data);

import axios from 'axios';

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

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

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/Channels/:ChannelSid/Messages',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Body: '',
    From: ''
  }
};

$.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, "Attributes=&Body=&From=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")
  .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/Channels/:ChannelSid/Messages',
  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({Attributes: '', Body: '', From: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Body: '', From: ''}
};

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/Channels/:ChannelSid/Messages');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages',
  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('Attributes', '');
encodedParams.set('Body', '');
encodedParams.set('From', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages';
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:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&From=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

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

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'Attributes' => '',
  'Body' => '',
  'From' => ''
]));

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

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

import http.client

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

payload = "Attributes=&Body=&From="

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

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

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

payload = {
    "Attributes": "",
    "Body": "",
    "From": ""
}
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/Channels/:ChannelSid/Messages"

payload <- "Attributes=&Body=&From="

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/Channels/:ChannelSid/Messages")

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

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

require 'faraday'

data = {
  :Attributes => "",
  :Body => "",
  :From => "",
}

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

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

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Body='' \
  From=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Body=&From=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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=&Permission=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Roles" {:form-params {:FriendlyName ""
                                                                                        :Permission ""
                                                                                        :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "FriendlyName=&Permission=&Type="

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/Roles"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FriendlyName", "" },
        { "Permission", "" },
        { "Type", "" },
    }),
};
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/Roles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "FriendlyName=&Permission=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("FriendlyName=&Permission=&Type=")

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

FriendlyName=&Permission=&Type=

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

client.close();

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

const data = 'FriendlyName=&Permission=&Type=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ServiceSid/Roles');
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('Permission', '');
encodedParams.set('Type', '');

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FriendlyName: '',
    Permission: '',
    Type: ''
  }
};

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

const request = require('request');

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

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

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

req.form({
  FriendlyName: '',
  Permission: '',
  Type: ''
});

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

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

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

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

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Roles",
  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=&Permission=&Type=",
  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/Roles', [
  'form_params' => [
    'FriendlyName' => '',
    'Permission' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'FriendlyName' => '',
  'Permission' => '',
  'Type' => ''
]));

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

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

import http.client

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

payload = "FriendlyName=&Permission=&Type="

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

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

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

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

import requests

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

payload = {
    "FriendlyName": "",
    "Permission": "",
    "Type": ""
}
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/Roles"

payload <- "FriendlyName=&Permission=&Type="

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/Roles")

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=&Permission=&Type="

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

require 'faraday'

data = {
  :FriendlyName => "",
  :Permission => "",
  :Type => "",
}

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

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

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Roles \
  content-type:application/x-www-form-urlencoded \
  FriendlyName='' \
  Permission='' \
  Type=''

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

import Foundation

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

let postData = NSMutableData(data: "FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Permission=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services" {:form-params {:FriendlyName ""}})

require "http/client"

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

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FriendlyName", "" },
    }),
};
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", "FriendlyName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

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

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

}

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

FriendlyName=

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "FriendlyName=");
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("FriendlyName=")
  .asString();

const data = 'FriendlyName=';

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FriendlyName: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "FriendlyName=")
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({FriendlyName: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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:[@"FriendlyName=" 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 "FriendlyName=" 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 => "FriendlyName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1/Services', [
  'form_params' => [
    'FriendlyName' => ''
  ],
  '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([
  'FriendlyName' => ''
]);

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

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

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

$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 'FriendlyName='

$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 'FriendlyName='

import http.client

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

payload = "FriendlyName="

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

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/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 = "FriendlyName="

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

require 'faraday'

data = {
  :FriendlyName => "",
}

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

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services \
  content-type:application/x-www-form-urlencoded \
  FriendlyName=''

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

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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, "Attributes=&FriendlyName=&Identity=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Users" {:form-params {:Attributes ""
                                                                                        :FriendlyName ""
                                                                                        :Identity ""
                                                                                        :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&Identity=&RoleSid="

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/Users"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "Identity", "" },
        { "RoleSid", "" },
    }),
};
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/Users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("Attributes=&FriendlyName=&Identity=&RoleSid=")

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

Attributes=&FriendlyName=&Identity=&RoleSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Users"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&Identity=&RoleSid="))
    .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, "Attributes=&FriendlyName=&Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users")
  .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/Users")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&Identity=&RoleSid=")
  .asString();

const data = 'Attributes=&FriendlyName=&Identity=&RoleSid=';

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

xhr.send(data);

import axios from 'axios';

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

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

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/Users',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    Identity: '',
    RoleSid: ''
  }
};

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''}
};

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

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

req.form({
  Attributes: '',
  FriendlyName: '',
  Identity: '',
  RoleSid: ''
});

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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users',
  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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Users';
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:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ServiceSid/Users" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&Identity=&RoleSid=" in

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

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

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'Identity' => '',
  'RoleSid' => ''
]));

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

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

import http.client

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

payload = "Attributes=&FriendlyName=&Identity=&RoleSid="

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

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

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

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

import requests

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

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "Identity": "",
    "RoleSid": ""
}
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/Users"

payload <- "Attributes=&FriendlyName=&Identity=&RoleSid="

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/Users")

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 = "Attributes=&FriendlyName=&Identity=&RoleSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :Identity => "",
  :RoleSid => "",
}

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

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

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "Identity": "",
        "RoleSid": ""
    });

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

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

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

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Users \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users

import Foundation

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

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Credentials/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Credentials/: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/Credentials/: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/Credentials/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Credentials/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Credentials/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Credentials/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Credentials/:Sid

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

DELETE /baseUrl/v1/Services/:Sid HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:Sid")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/v1/Services/:Sid');

xhr.send(data);

import axios from 'axios';

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

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:Sid',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:Sid" in

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

 "{{baseUrl}}/v1/Services/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/v1/Services/:Sid');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/v1/Services/:Sid') do |req|
end

puts response.status
puts response.body

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

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:Sid

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Credentials/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Credentials/: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/Credentials/: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/Credentials/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/v1/Credentials/: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/Credentials/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Credentials/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Credentials/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Credentials/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Credentials/:Sid

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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/Roles/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:Sid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:Sid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/Services/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:Sid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/: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/Users/: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/Users/: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/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/: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/Users/: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/Users/: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/Users/: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/Users/: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/Users/: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/Users/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Users/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels"

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/Channels"),
};
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/Channels");
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/Channels"

	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/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels"))
    .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/Channels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .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/Channels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels';
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/Channels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .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/Channels',
  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/Channels'
};

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/Channels');

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/Channels'
};

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/Channels';
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/Channels"]
                                                       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/Channels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels",
  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/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels")

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/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Credentials")

require "http/client"

url = "{{baseUrl}}/v1/Credentials"

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/Credentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Credentials"

	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/Credentials HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Credentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials"))
    .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/Credentials")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Credentials")
  .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/Credentials');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Credentials';
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/Credentials',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Credentials',
  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/Credentials'};

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/Credentials');

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/Credentials'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Credentials';
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/Credentials"]
                                                       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/Credentials" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Credentials",
  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/Credentials');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Credentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Credentials")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Credentials")

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/Credentials') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Credentials";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Credentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Credentials

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

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/Channels/:ChannelSid/Invites"),
};
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/Channels/:ChannelSid/Invites");
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/Channels/:ChannelSid/Invites"

	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/Channels/:ChannelSid/Invites HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"))
    .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/Channels/:ChannelSid/Invites")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/Channels/:ChannelSid/Invites');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites';
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/Channels/:ChannelSid/Invites',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/Channels/:ChannelSid/Invites',
  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/Channels/:ChannelSid/Invites'
};

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/Channels/:ChannelSid/Invites');

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/Channels/:ChannelSid/Invites'
};

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/Channels/:ChannelSid/Invites';
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/Channels/:ChannelSid/Invites"]
                                                       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/Channels/:ChannelSid/Invites" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites",
  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/Channels/:ChannelSid/Invites');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")

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/Channels/:ChannelSid/Invites') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

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/Channels/:ChannelSid/Members"),
};
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/Channels/:ChannelSid/Members");
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/Channels/:ChannelSid/Members"

	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/Channels/:ChannelSid/Members HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"))
    .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/Channels/:ChannelSid/Members")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/Channels/:ChannelSid/Members');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members';
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/Channels/:ChannelSid/Members',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/Channels/:ChannelSid/Members',
  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/Channels/:ChannelSid/Members'
};

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/Channels/:ChannelSid/Members');

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/Channels/:ChannelSid/Members'
};

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/Channels/:ChannelSid/Members';
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/Channels/:ChannelSid/Members"]
                                                       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/Channels/:ChannelSid/Members" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members",
  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/Channels/:ChannelSid/Members');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")

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/Channels/:ChannelSid/Members') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

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/Channels/:ChannelSid/Messages"),
};
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/Channels/:ChannelSid/Messages");
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/Channels/:ChannelSid/Messages"

	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/Channels/:ChannelSid/Messages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"))
    .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/Channels/:ChannelSid/Messages")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")
  .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/Channels/:ChannelSid/Messages');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages';
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/Channels/:ChannelSid/Messages',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")
  .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/Channels/:ChannelSid/Messages',
  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/Channels/:ChannelSid/Messages'
};

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/Channels/:ChannelSid/Messages');

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/Channels/:ChannelSid/Messages'
};

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/Channels/:ChannelSid/Messages';
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/Channels/:ChannelSid/Messages"]
                                                       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/Channels/:ChannelSid/Messages" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages",
  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/Channels/:ChannelSid/Messages');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")

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/Channels/:ChannelSid/Messages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Roles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Roles")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles"

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/Roles"),
};
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/Roles");
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/Roles"

	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/Roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Roles"))
    .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/Roles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Roles")
  .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/Roles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Roles';
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/Roles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Roles")
  .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/Roles',
  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/Roles'
};

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/Roles');

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/Roles'
};

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/Roles';
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/Roles"]
                                                       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/Roles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Roles",
  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/Roles');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Roles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Roles")

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/Roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services")

require "http/client"

url = "{{baseUrl}}/v1/Services"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/Services');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Users")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users"

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/Users"),
};
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/Users");
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/Users"

	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/Users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Users"))
    .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/Users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Users")
  .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/Users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Users';
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/Users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users")
  .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/Users',
  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/Users'
};

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/Users');

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/Users'
};

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/Users';
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/Users"]
                                                       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/Users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Users",
  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/Users');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Users")

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/Users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

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/Users/:UserSid/Channels"),
};
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/Users/:UserSid/Channels");
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/Users/:UserSid/Channels"

	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/Users/:UserSid/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"))
    .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/Users/:UserSid/Channels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")
  .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/Users/:UserSid/Channels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels';
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/Users/:UserSid/Channels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")
  .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/Users/:UserSid/Channels',
  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/Users/:UserSid/Channels'
};

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/Users/:UserSid/Channels');

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/Users/:UserSid/Channels'
};

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/Users/:UserSid/Channels';
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/Users/:UserSid/Channels"]
                                                       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/Users/:UserSid/Channels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels",
  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/Users/:UserSid/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Users/:UserSid/Channels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")

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/Users/:UserSid/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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, "Attributes=&FriendlyName=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid" {:form-params {:Attributes ""
                                                                                                :FriendlyName ""
                                                                                                :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&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/Channels/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "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/Channels/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

	payload := strings.NewReader("Attributes=&FriendlyName=&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/Channels/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 37

Attributes=&FriendlyName=&UniqueName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&FriendlyName=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&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, "Attributes=&FriendlyName=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/Channels/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&UniqueName=")
  .asString();

const data = 'Attributes=&FriendlyName=&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/Channels/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/Channels/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', 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/Channels/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    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, "Attributes=&FriendlyName=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/Channels/: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({Attributes: '', FriendlyName: '', UniqueName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', 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/Channels/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  FriendlyName: '',
  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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/Channels/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&UniqueName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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 => "Attributes=&FriendlyName=&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/Channels/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'FriendlyName' => '',
  'UniqueName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/Channels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&UniqueName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&FriendlyName=&UniqueName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "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/Channels/:Sid"

payload <- "Attributes=&FriendlyName=&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/Channels/: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 = "Attributes=&FriendlyName=&UniqueName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :UniqueName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/: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/Channels/:Sid";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "UniqueName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials/: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, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Credentials/:Sid" {:form-params {:ApiKey ""
                                                                              :Certificate ""
                                                                              :FriendlyName ""
                                                                              :PrivateKey ""
                                                                              :Sandbox ""
                                                                              :Secret ""}})

require "http/client"

url = "{{baseUrl}}/v1/Credentials/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret="

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/Credentials/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ApiKey", "" },
        { "Certificate", "" },
        { "FriendlyName", "" },
        { "PrivateKey", "" },
        { "Sandbox", "" },
        { "Secret", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Credentials/:Sid"

	payload := strings.NewReader("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=")

	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/Credentials/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 63

ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Credentials/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret="))
    .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, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Credentials/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=")
  .asString();

const data = 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=';

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/Credentials/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials/: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/Credentials/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: ''
  })
};

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/Credentials/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: ''
  }
};

$.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, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/: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/Credentials/: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({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: ''
  }
};

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/Credentials/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: ''
});

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('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials/: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('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');

const url = '{{baseUrl}}/v1/Credentials/: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:[@"ApiKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Certificate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PrivateKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Sandbox=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Secret=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Credentials/: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/Credentials/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Credentials/: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 => "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=",
  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/Credentials/:Sid', [
  'form_params' => [
    'ApiKey' => '',
    'Certificate' => '',
    'FriendlyName' => '',
    'PrivateKey' => '',
    'Sandbox' => '',
    'Secret' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Credentials/: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/Credentials/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Credentials/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials/:Sid"

payload = {
    "ApiKey": "",
    "Certificate": "",
    "FriendlyName": "",
    "PrivateKey": "",
    "Sandbox": "",
    "Secret": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials/:Sid"

payload <- "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret="

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/Credentials/: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 = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :ApiKey => "",
  :Certificate => "",
  :FriendlyName => "",
  :PrivateKey => "",
  :Sandbox => "",
  :Secret => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Credentials/: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/Credentials/:Sid";

    let payload = json!({
        "ApiKey": "",
        "Certificate": "",
        "FriendlyName": "",
        "PrivateKey": "",
        "Sandbox": "",
        "Secret": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Credentials/:Sid \
  content-type:application/x-www-form-urlencoded \
  ApiKey='' \
  Certificate='' \
  FriendlyName='' \
  PrivateKey='' \
  Sandbox='' \
  Secret=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=' \
  --output-document \
  - {{baseUrl}}/v1/Credentials/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ApiKey=".data(using: String.Encoding.utf8)!)
postData.append("&Certificate=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&PrivateKey=".data(using: String.Encoding.utf8)!)
postData.append("&Sandbox=".data(using: String.Encoding.utf8)!)
postData.append("&Secret=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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, "LastConsumedMessageIndex=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid" {:form-params {:LastConsumedMessageIndex ""
                                                                                                                    :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "LastConsumedMessageIndex=&RoleSid="

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/Channels/:ChannelSid/Members/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "LastConsumedMessageIndex", "" },
        { "RoleSid", "" },
    }),
};
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/Channels/:ChannelSid/Members/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "LastConsumedMessageIndex=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

	payload := strings.NewReader("LastConsumedMessageIndex=&RoleSid=")

	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/Channels/:ChannelSid/Members/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 34

LastConsumedMessageIndex=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("LastConsumedMessageIndex=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("LastConsumedMessageIndex=&RoleSid="))
    .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, "LastConsumedMessageIndex=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/Channels/:ChannelSid/Members/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("LastConsumedMessageIndex=&RoleSid=")
  .asString();

const data = 'LastConsumedMessageIndex=&RoleSid=';

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/Channels/:ChannelSid/Members/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('LastConsumedMessageIndex', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/Channels/:ChannelSid/Members/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({LastConsumedMessageIndex: '', RoleSid: ''})
};

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/Channels/:ChannelSid/Members/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    LastConsumedMessageIndex: '',
    RoleSid: ''
  }
};

$.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, "LastConsumedMessageIndex=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/Channels/:ChannelSid/Members/: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({LastConsumedMessageIndex: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {LastConsumedMessageIndex: '', RoleSid: ''}
};

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/Channels/:ChannelSid/Members/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  LastConsumedMessageIndex: '',
  RoleSid: ''
});

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('LastConsumedMessageIndex', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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('LastConsumedMessageIndex', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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:[@"LastConsumedMessageIndex=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/Channels/:ChannelSid/Members/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "LastConsumedMessageIndex=&RoleSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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 => "LastConsumedMessageIndex=&RoleSid=",
  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/Channels/:ChannelSid/Members/:Sid', [
  'form_params' => [
    'LastConsumedMessageIndex' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'LastConsumedMessageIndex' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'LastConsumedMessageIndex' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/Channels/:ChannelSid/Members/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastConsumedMessageIndex=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastConsumedMessageIndex=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "LastConsumedMessageIndex=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

payload = {
    "LastConsumedMessageIndex": "",
    "RoleSid": ""
}
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/Channels/:ChannelSid/Members/:Sid"

payload <- "LastConsumedMessageIndex=&RoleSid="

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/Channels/:ChannelSid/Members/: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 = "LastConsumedMessageIndex=&RoleSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :LastConsumedMessageIndex => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/Channels/:ChannelSid/Members/:Sid";

    let payload = json!({
        "LastConsumedMessageIndex": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid \
  content-type:application/x-www-form-urlencoded \
  LastConsumedMessageIndex='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'LastConsumedMessageIndex=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "LastConsumedMessageIndex=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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, "Attributes=&Body=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid" {:form-params {:Attributes ""
                                                                                                                     :Body ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Body="

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/Channels/:ChannelSid/Messages/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Body", "" },
    }),
};
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/Channels/:ChannelSid/Messages/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Body=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

	payload := strings.NewReader("Attributes=&Body=")

	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/Channels/:ChannelSid/Messages/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

Attributes=&Body=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&Body=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Body="))
    .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, "Attributes=&Body=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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/Channels/:ChannelSid/Messages/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Body=")
  .asString();

const data = 'Attributes=&Body=';

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/Channels/:ChannelSid/Messages/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Body', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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/Channels/:ChannelSid/Messages/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', Body: ''})
};

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/Channels/:ChannelSid/Messages/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Body: ''
  }
};

$.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, "Attributes=&Body=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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/Channels/:ChannelSid/Messages/: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({Attributes: '', Body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Body: ''}
};

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/Channels/:ChannelSid/Messages/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  Body: ''
});

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('Attributes', '');
encodedParams.set('Body', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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('Attributes', '');
encodedParams.set('Body', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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/Channels/:ChannelSid/Messages/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Body=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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 => "Attributes=&Body=",
  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/Channels/:ChannelSid/Messages/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'Body' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'Body' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'Body' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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/Channels/:ChannelSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Body='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Body='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&Body="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

payload = {
    "Attributes": "",
    "Body": ""
}
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/Channels/:ChannelSid/Messages/:Sid"

payload <- "Attributes=&Body="

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/Channels/:ChannelSid/Messages/: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 = "Attributes=&Body="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :Body => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/: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/Channels/:ChannelSid/Messages/:Sid";

    let payload = json!({
        "Attributes": "",
        "Body": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Body=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Body=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Body=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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, "Permission=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid" {:form-params {:Permission ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Permission="

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/Roles/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Permission", "" },
    }),
};
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/Roles/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Permission=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

	payload := strings.NewReader("Permission=")

	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/Roles/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

Permission=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Permission=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Permission="))
    .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, "Permission=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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/Roles/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Permission=")
  .asString();

const data = 'Permission=';

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/Roles/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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/Roles/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Permission: ''})
};

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/Roles/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Permission: ''
  }
};

$.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, "Permission=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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/Roles/: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({Permission: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Permission: ''}
};

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/Roles/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Permission: ''
});

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('Permission', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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('Permission', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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:[@"Permission=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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/Roles/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Permission=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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 => "Permission=",
  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/Roles/:Sid', [
  'form_params' => [
    'Permission' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Permission' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Permission' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles/: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/Roles/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Permission='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Permission='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Permission="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Roles/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

payload = { "Permission": "" }
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/Roles/:Sid"

payload <- "Permission="

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/Roles/: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 = "Permission="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Permission => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Roles/: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/Roles/:Sid";

    let payload = json!({"Permission": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid \
  content-type:application/x-www-form-urlencoded \
  Permission=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Permission= \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Permission=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/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, "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:Sid" {:form-params {:ConsumptionReportInterval ""
                                                                           :DefaultChannelCreatorRoleSid ""
                                                                           :DefaultChannelRoleSid ""
                                                                           :DefaultServiceRoleSid ""
                                                                           :FriendlyName ""
                                                                           :Limits.ChannelMembers ""
                                                                           :Limits.UserChannels ""
                                                                           :Notifications.AddedToChannel.Enabled ""
                                                                           :Notifications.AddedToChannel.Template ""
                                                                           :Notifications.InvitedToChannel.Enabled ""
                                                                           :Notifications.InvitedToChannel.Template ""
                                                                           :Notifications.NewMessage.Enabled ""
                                                                           :Notifications.NewMessage.Template ""
                                                                           :Notifications.RemovedFromChannel.Enabled ""
                                                                           :Notifications.RemovedFromChannel.Template ""
                                                                           :PostWebhookUrl ""
                                                                           :PreWebhookUrl ""
                                                                           :ReachabilityEnabled ""
                                                                           :ReadStatusEnabled ""
                                                                           :TypingIndicatorTimeout ""
                                                                           :WebhookFilters ""
                                                                           :WebhookMethod ""
                                                                           :Webhooks.OnChannelAdd.Method ""
                                                                           :Webhooks.OnChannelAdd.Url ""
                                                                           :Webhooks.OnChannelAdded.Method ""
                                                                           :Webhooks.OnChannelAdded.Url ""
                                                                           :Webhooks.OnChannelDestroy.Method ""
                                                                           :Webhooks.OnChannelDestroy.Url ""
                                                                           :Webhooks.OnChannelDestroyed.Method ""
                                                                           :Webhooks.OnChannelDestroyed.Url ""
                                                                           :Webhooks.OnChannelUpdate.Method ""
                                                                           :Webhooks.OnChannelUpdate.Url ""
                                                                           :Webhooks.OnChannelUpdated.Method ""
                                                                           :Webhooks.OnChannelUpdated.Url ""
                                                                           :Webhooks.OnMemberAdd.Method ""
                                                                           :Webhooks.OnMemberAdd.Url ""
                                                                           :Webhooks.OnMemberAdded.Method ""
                                                                           :Webhooks.OnMemberAdded.Url ""
                                                                           :Webhooks.OnMemberRemove.Method ""
                                                                           :Webhooks.OnMemberRemove.Url ""
                                                                           :Webhooks.OnMemberRemoved.Method ""
                                                                           :Webhooks.OnMemberRemoved.Url ""
                                                                           :Webhooks.OnMessageRemove.Method ""
                                                                           :Webhooks.OnMessageRemove.Url ""
                                                                           :Webhooks.OnMessageRemoved.Method ""
                                                                           :Webhooks.OnMessageRemoved.Url ""
                                                                           :Webhooks.OnMessageSend.Method ""
                                                                           :Webhooks.OnMessageSend.Url ""
                                                                           :Webhooks.OnMessageSent.Method ""
                                                                           :Webhooks.OnMessageSent.Url ""
                                                                           :Webhooks.OnMessageUpdate.Method ""
                                                                           :Webhooks.OnMessageUpdate.Url ""
                                                                           :Webhooks.OnMessageUpdated.Method ""
                                                                           :Webhooks.OnMessageUpdated.Url ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="

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
    {
        { "ConsumptionReportInterval", "" },
        { "DefaultChannelCreatorRoleSid", "" },
        { "DefaultChannelRoleSid", "" },
        { "DefaultServiceRoleSid", "" },
        { "FriendlyName", "" },
        { "Limits.ChannelMembers", "" },
        { "Limits.UserChannels", "" },
        { "Notifications.AddedToChannel.Enabled", "" },
        { "Notifications.AddedToChannel.Template", "" },
        { "Notifications.InvitedToChannel.Enabled", "" },
        { "Notifications.InvitedToChannel.Template", "" },
        { "Notifications.NewMessage.Enabled", "" },
        { "Notifications.NewMessage.Template", "" },
        { "Notifications.RemovedFromChannel.Enabled", "" },
        { "Notifications.RemovedFromChannel.Template", "" },
        { "PostWebhookUrl", "" },
        { "PreWebhookUrl", "" },
        { "ReachabilityEnabled", "" },
        { "ReadStatusEnabled", "" },
        { "TypingIndicatorTimeout", "" },
        { "WebhookFilters", "" },
        { "WebhookMethod", "" },
        { "Webhooks.OnChannelAdd.Method", "" },
        { "Webhooks.OnChannelAdd.Url", "" },
        { "Webhooks.OnChannelAdded.Method", "" },
        { "Webhooks.OnChannelAdded.Url", "" },
        { "Webhooks.OnChannelDestroy.Method", "" },
        { "Webhooks.OnChannelDestroy.Url", "" },
        { "Webhooks.OnChannelDestroyed.Method", "" },
        { "Webhooks.OnChannelDestroyed.Url", "" },
        { "Webhooks.OnChannelUpdate.Method", "" },
        { "Webhooks.OnChannelUpdate.Url", "" },
        { "Webhooks.OnChannelUpdated.Method", "" },
        { "Webhooks.OnChannelUpdated.Url", "" },
        { "Webhooks.OnMemberAdd.Method", "" },
        { "Webhooks.OnMemberAdd.Url", "" },
        { "Webhooks.OnMemberAdded.Method", "" },
        { "Webhooks.OnMemberAdded.Url", "" },
        { "Webhooks.OnMemberRemove.Method", "" },
        { "Webhooks.OnMemberRemove.Url", "" },
        { "Webhooks.OnMemberRemoved.Method", "" },
        { "Webhooks.OnMemberRemoved.Url", "" },
        { "Webhooks.OnMessageRemove.Method", "" },
        { "Webhooks.OnMessageRemove.Url", "" },
        { "Webhooks.OnMessageRemoved.Method", "" },
        { "Webhooks.OnMessageRemoved.Url", "" },
        { "Webhooks.OnMessageSend.Method", "" },
        { "Webhooks.OnMessageSend.Url", "" },
        { "Webhooks.OnMessageSent.Method", "" },
        { "Webhooks.OnMessageSent.Url", "" },
        { "Webhooks.OnMessageUpdate.Method", "" },
        { "Webhooks.OnMessageUpdate.Url", "" },
        { "Webhooks.OnMessageUpdated.Method", "" },
        { "Webhooks.OnMessageUpdated.Url", "" },
    }),
};
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", "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=", 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("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")

	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: 1590

ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")
  .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("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="))
    .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, "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=");
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("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")
  .asString();

const data = 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=';

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('ConsumptionReportInterval', '');
encodedParams.set('DefaultChannelCreatorRoleSid', '');
encodedParams.set('DefaultChannelRoleSid', '');
encodedParams.set('DefaultServiceRoleSid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Limits.ChannelMembers', '');
encodedParams.set('Limits.UserChannels', '');
encodedParams.set('Notifications.AddedToChannel.Enabled', '');
encodedParams.set('Notifications.AddedToChannel.Template', '');
encodedParams.set('Notifications.InvitedToChannel.Enabled', '');
encodedParams.set('Notifications.InvitedToChannel.Template', '');
encodedParams.set('Notifications.NewMessage.Enabled', '');
encodedParams.set('Notifications.NewMessage.Template', '');
encodedParams.set('Notifications.RemovedFromChannel.Enabled', '');
encodedParams.set('Notifications.RemovedFromChannel.Template', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('ReachabilityEnabled', '');
encodedParams.set('ReadStatusEnabled', '');
encodedParams.set('TypingIndicatorTimeout', '');
encodedParams.set('WebhookFilters', '');
encodedParams.set('WebhookMethod', '');
encodedParams.set('Webhooks.OnChannelAdd.Method', '');
encodedParams.set('Webhooks.OnChannelAdd.Url', '');
encodedParams.set('Webhooks.OnChannelAdded.Method', '');
encodedParams.set('Webhooks.OnChannelAdded.Url', '');
encodedParams.set('Webhooks.OnChannelDestroy.Method', '');
encodedParams.set('Webhooks.OnChannelDestroy.Url', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Method', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Url', '');
encodedParams.set('Webhooks.OnChannelUpdate.Method', '');
encodedParams.set('Webhooks.OnChannelUpdate.Url', '');
encodedParams.set('Webhooks.OnChannelUpdated.Method', '');
encodedParams.set('Webhooks.OnChannelUpdated.Url', '');
encodedParams.set('Webhooks.OnMemberAdd.Method', '');
encodedParams.set('Webhooks.OnMemberAdd.Url', '');
encodedParams.set('Webhooks.OnMemberAdded.Method', '');
encodedParams.set('Webhooks.OnMemberAdded.Url', '');
encodedParams.set('Webhooks.OnMemberRemove.Method', '');
encodedParams.set('Webhooks.OnMemberRemove.Url', '');
encodedParams.set('Webhooks.OnMemberRemoved.Method', '');
encodedParams.set('Webhooks.OnMemberRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageRemove.Method', '');
encodedParams.set('Webhooks.OnMessageRemove.Url', '');
encodedParams.set('Webhooks.OnMessageRemoved.Method', '');
encodedParams.set('Webhooks.OnMessageRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageSend.Method', '');
encodedParams.set('Webhooks.OnMessageSend.Url', '');
encodedParams.set('Webhooks.OnMessageSent.Method', '');
encodedParams.set('Webhooks.OnMessageSent.Url', '');
encodedParams.set('Webhooks.OnMessageUpdate.Method', '');
encodedParams.set('Webhooks.OnMessageUpdate.Url', '');
encodedParams.set('Webhooks.OnMessageUpdated.Method', '');
encodedParams.set('Webhooks.OnMessageUpdated.Url', '');

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({
    ConsumptionReportInterval: '',
    DefaultChannelCreatorRoleSid: '',
    DefaultChannelRoleSid: '',
    DefaultServiceRoleSid: '',
    FriendlyName: '',
    'Limits.ChannelMembers': '',
    'Limits.UserChannels': '',
    'Notifications.AddedToChannel.Enabled': '',
    'Notifications.AddedToChannel.Template': '',
    'Notifications.InvitedToChannel.Enabled': '',
    'Notifications.InvitedToChannel.Template': '',
    'Notifications.NewMessage.Enabled': '',
    'Notifications.NewMessage.Template': '',
    'Notifications.RemovedFromChannel.Enabled': '',
    'Notifications.RemovedFromChannel.Template': '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    ReachabilityEnabled: '',
    ReadStatusEnabled: '',
    TypingIndicatorTimeout: '',
    WebhookFilters: '',
    WebhookMethod: '',
    'Webhooks.OnChannelAdd.Method': '',
    'Webhooks.OnChannelAdd.Url': '',
    'Webhooks.OnChannelAdded.Method': '',
    'Webhooks.OnChannelAdded.Url': '',
    'Webhooks.OnChannelDestroy.Method': '',
    'Webhooks.OnChannelDestroy.Url': '',
    'Webhooks.OnChannelDestroyed.Method': '',
    'Webhooks.OnChannelDestroyed.Url': '',
    'Webhooks.OnChannelUpdate.Method': '',
    'Webhooks.OnChannelUpdate.Url': '',
    'Webhooks.OnChannelUpdated.Method': '',
    'Webhooks.OnChannelUpdated.Url': '',
    'Webhooks.OnMemberAdd.Method': '',
    'Webhooks.OnMemberAdd.Url': '',
    'Webhooks.OnMemberAdded.Method': '',
    'Webhooks.OnMemberAdded.Url': '',
    'Webhooks.OnMemberRemove.Method': '',
    'Webhooks.OnMemberRemove.Url': '',
    'Webhooks.OnMemberRemoved.Method': '',
    'Webhooks.OnMemberRemoved.Url': '',
    'Webhooks.OnMessageRemove.Method': '',
    'Webhooks.OnMessageRemove.Url': '',
    'Webhooks.OnMessageRemoved.Method': '',
    'Webhooks.OnMessageRemoved.Url': '',
    'Webhooks.OnMessageSend.Method': '',
    'Webhooks.OnMessageSend.Url': '',
    'Webhooks.OnMessageSent.Method': '',
    'Webhooks.OnMessageSent.Url': '',
    'Webhooks.OnMessageUpdate.Method': '',
    'Webhooks.OnMessageUpdate.Url': '',
    'Webhooks.OnMessageUpdated.Method': '',
    'Webhooks.OnMessageUpdated.Url': ''
  })
};

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: {
    ConsumptionReportInterval: '',
    DefaultChannelCreatorRoleSid: '',
    DefaultChannelRoleSid: '',
    DefaultServiceRoleSid: '',
    FriendlyName: '',
    'Limits.ChannelMembers': '',
    'Limits.UserChannels': '',
    'Notifications.AddedToChannel.Enabled': '',
    'Notifications.AddedToChannel.Template': '',
    'Notifications.InvitedToChannel.Enabled': '',
    'Notifications.InvitedToChannel.Template': '',
    'Notifications.NewMessage.Enabled': '',
    'Notifications.NewMessage.Template': '',
    'Notifications.RemovedFromChannel.Enabled': '',
    'Notifications.RemovedFromChannel.Template': '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    ReachabilityEnabled: '',
    ReadStatusEnabled: '',
    TypingIndicatorTimeout: '',
    WebhookFilters: '',
    WebhookMethod: '',
    'Webhooks.OnChannelAdd.Method': '',
    'Webhooks.OnChannelAdd.Url': '',
    'Webhooks.OnChannelAdded.Method': '',
    'Webhooks.OnChannelAdded.Url': '',
    'Webhooks.OnChannelDestroy.Method': '',
    'Webhooks.OnChannelDestroy.Url': '',
    'Webhooks.OnChannelDestroyed.Method': '',
    'Webhooks.OnChannelDestroyed.Url': '',
    'Webhooks.OnChannelUpdate.Method': '',
    'Webhooks.OnChannelUpdate.Url': '',
    'Webhooks.OnChannelUpdated.Method': '',
    'Webhooks.OnChannelUpdated.Url': '',
    'Webhooks.OnMemberAdd.Method': '',
    'Webhooks.OnMemberAdd.Url': '',
    'Webhooks.OnMemberAdded.Method': '',
    'Webhooks.OnMemberAdded.Url': '',
    'Webhooks.OnMemberRemove.Method': '',
    'Webhooks.OnMemberRemove.Url': '',
    'Webhooks.OnMemberRemoved.Method': '',
    'Webhooks.OnMemberRemoved.Url': '',
    'Webhooks.OnMessageRemove.Method': '',
    'Webhooks.OnMessageRemove.Url': '',
    'Webhooks.OnMessageRemoved.Method': '',
    'Webhooks.OnMessageRemoved.Url': '',
    'Webhooks.OnMessageSend.Method': '',
    'Webhooks.OnMessageSend.Url': '',
    'Webhooks.OnMessageSent.Method': '',
    'Webhooks.OnMessageSent.Url': '',
    'Webhooks.OnMessageUpdate.Method': '',
    'Webhooks.OnMessageUpdate.Url': '',
    'Webhooks.OnMessageUpdated.Method': '',
    'Webhooks.OnMessageUpdated.Url': ''
  }
};

$.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, "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")
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({
  ConsumptionReportInterval: '',
  DefaultChannelCreatorRoleSid: '',
  DefaultChannelRoleSid: '',
  DefaultServiceRoleSid: '',
  FriendlyName: '',
  'Limits.ChannelMembers': '',
  'Limits.UserChannels': '',
  'Notifications.AddedToChannel.Enabled': '',
  'Notifications.AddedToChannel.Template': '',
  'Notifications.InvitedToChannel.Enabled': '',
  'Notifications.InvitedToChannel.Template': '',
  'Notifications.NewMessage.Enabled': '',
  'Notifications.NewMessage.Template': '',
  'Notifications.RemovedFromChannel.Enabled': '',
  'Notifications.RemovedFromChannel.Template': '',
  PostWebhookUrl: '',
  PreWebhookUrl: '',
  ReachabilityEnabled: '',
  ReadStatusEnabled: '',
  TypingIndicatorTimeout: '',
  WebhookFilters: '',
  WebhookMethod: '',
  'Webhooks.OnChannelAdd.Method': '',
  'Webhooks.OnChannelAdd.Url': '',
  'Webhooks.OnChannelAdded.Method': '',
  'Webhooks.OnChannelAdded.Url': '',
  'Webhooks.OnChannelDestroy.Method': '',
  'Webhooks.OnChannelDestroy.Url': '',
  'Webhooks.OnChannelDestroyed.Method': '',
  'Webhooks.OnChannelDestroyed.Url': '',
  'Webhooks.OnChannelUpdate.Method': '',
  'Webhooks.OnChannelUpdate.Url': '',
  'Webhooks.OnChannelUpdated.Method': '',
  'Webhooks.OnChannelUpdated.Url': '',
  'Webhooks.OnMemberAdd.Method': '',
  'Webhooks.OnMemberAdd.Url': '',
  'Webhooks.OnMemberAdded.Method': '',
  'Webhooks.OnMemberAdded.Url': '',
  'Webhooks.OnMemberRemove.Method': '',
  'Webhooks.OnMemberRemove.Url': '',
  'Webhooks.OnMemberRemoved.Method': '',
  'Webhooks.OnMemberRemoved.Url': '',
  'Webhooks.OnMessageRemove.Method': '',
  'Webhooks.OnMessageRemove.Url': '',
  'Webhooks.OnMessageRemoved.Method': '',
  'Webhooks.OnMessageRemoved.Url': '',
  'Webhooks.OnMessageSend.Method': '',
  'Webhooks.OnMessageSend.Url': '',
  'Webhooks.OnMessageSent.Method': '',
  'Webhooks.OnMessageSent.Url': '',
  'Webhooks.OnMessageUpdate.Method': '',
  'Webhooks.OnMessageUpdate.Url': '',
  'Webhooks.OnMessageUpdated.Method': '',
  'Webhooks.OnMessageUpdated.Url': ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ConsumptionReportInterval: '',
    DefaultChannelCreatorRoleSid: '',
    DefaultChannelRoleSid: '',
    DefaultServiceRoleSid: '',
    FriendlyName: '',
    'Limits.ChannelMembers': '',
    'Limits.UserChannels': '',
    'Notifications.AddedToChannel.Enabled': '',
    'Notifications.AddedToChannel.Template': '',
    'Notifications.InvitedToChannel.Enabled': '',
    'Notifications.InvitedToChannel.Template': '',
    'Notifications.NewMessage.Enabled': '',
    'Notifications.NewMessage.Template': '',
    'Notifications.RemovedFromChannel.Enabled': '',
    'Notifications.RemovedFromChannel.Template': '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    ReachabilityEnabled: '',
    ReadStatusEnabled: '',
    TypingIndicatorTimeout: '',
    WebhookFilters: '',
    WebhookMethod: '',
    'Webhooks.OnChannelAdd.Method': '',
    'Webhooks.OnChannelAdd.Url': '',
    'Webhooks.OnChannelAdded.Method': '',
    'Webhooks.OnChannelAdded.Url': '',
    'Webhooks.OnChannelDestroy.Method': '',
    'Webhooks.OnChannelDestroy.Url': '',
    'Webhooks.OnChannelDestroyed.Method': '',
    'Webhooks.OnChannelDestroyed.Url': '',
    'Webhooks.OnChannelUpdate.Method': '',
    'Webhooks.OnChannelUpdate.Url': '',
    'Webhooks.OnChannelUpdated.Method': '',
    'Webhooks.OnChannelUpdated.Url': '',
    'Webhooks.OnMemberAdd.Method': '',
    'Webhooks.OnMemberAdd.Url': '',
    'Webhooks.OnMemberAdded.Method': '',
    'Webhooks.OnMemberAdded.Url': '',
    'Webhooks.OnMemberRemove.Method': '',
    'Webhooks.OnMemberRemove.Url': '',
    'Webhooks.OnMemberRemoved.Method': '',
    'Webhooks.OnMemberRemoved.Url': '',
    'Webhooks.OnMessageRemove.Method': '',
    'Webhooks.OnMessageRemove.Url': '',
    'Webhooks.OnMessageRemoved.Method': '',
    'Webhooks.OnMessageRemoved.Url': '',
    'Webhooks.OnMessageSend.Method': '',
    'Webhooks.OnMessageSend.Url': '',
    'Webhooks.OnMessageSent.Method': '',
    'Webhooks.OnMessageSent.Url': '',
    'Webhooks.OnMessageUpdate.Method': '',
    'Webhooks.OnMessageUpdate.Url': '',
    'Webhooks.OnMessageUpdated.Method': '',
    'Webhooks.OnMessageUpdated.Url': ''
  }
};

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({
  ConsumptionReportInterval: '',
  DefaultChannelCreatorRoleSid: '',
  DefaultChannelRoleSid: '',
  DefaultServiceRoleSid: '',
  FriendlyName: '',
  'Limits.ChannelMembers': '',
  'Limits.UserChannels': '',
  'Notifications.AddedToChannel.Enabled': '',
  'Notifications.AddedToChannel.Template': '',
  'Notifications.InvitedToChannel.Enabled': '',
  'Notifications.InvitedToChannel.Template': '',
  'Notifications.NewMessage.Enabled': '',
  'Notifications.NewMessage.Template': '',
  'Notifications.RemovedFromChannel.Enabled': '',
  'Notifications.RemovedFromChannel.Template': '',
  PostWebhookUrl: '',
  PreWebhookUrl: '',
  ReachabilityEnabled: '',
  ReadStatusEnabled: '',
  TypingIndicatorTimeout: '',
  WebhookFilters: '',
  WebhookMethod: '',
  'Webhooks.OnChannelAdd.Method': '',
  'Webhooks.OnChannelAdd.Url': '',
  'Webhooks.OnChannelAdded.Method': '',
  'Webhooks.OnChannelAdded.Url': '',
  'Webhooks.OnChannelDestroy.Method': '',
  'Webhooks.OnChannelDestroy.Url': '',
  'Webhooks.OnChannelDestroyed.Method': '',
  'Webhooks.OnChannelDestroyed.Url': '',
  'Webhooks.OnChannelUpdate.Method': '',
  'Webhooks.OnChannelUpdate.Url': '',
  'Webhooks.OnChannelUpdated.Method': '',
  'Webhooks.OnChannelUpdated.Url': '',
  'Webhooks.OnMemberAdd.Method': '',
  'Webhooks.OnMemberAdd.Url': '',
  'Webhooks.OnMemberAdded.Method': '',
  'Webhooks.OnMemberAdded.Url': '',
  'Webhooks.OnMemberRemove.Method': '',
  'Webhooks.OnMemberRemove.Url': '',
  'Webhooks.OnMemberRemoved.Method': '',
  'Webhooks.OnMemberRemoved.Url': '',
  'Webhooks.OnMessageRemove.Method': '',
  'Webhooks.OnMessageRemove.Url': '',
  'Webhooks.OnMessageRemoved.Method': '',
  'Webhooks.OnMessageRemoved.Url': '',
  'Webhooks.OnMessageSend.Method': '',
  'Webhooks.OnMessageSend.Url': '',
  'Webhooks.OnMessageSent.Method': '',
  'Webhooks.OnMessageSent.Url': '',
  'Webhooks.OnMessageUpdate.Method': '',
  'Webhooks.OnMessageUpdate.Url': '',
  'Webhooks.OnMessageUpdated.Method': '',
  'Webhooks.OnMessageUpdated.Url': ''
});

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('ConsumptionReportInterval', '');
encodedParams.set('DefaultChannelCreatorRoleSid', '');
encodedParams.set('DefaultChannelRoleSid', '');
encodedParams.set('DefaultServiceRoleSid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Limits.ChannelMembers', '');
encodedParams.set('Limits.UserChannels', '');
encodedParams.set('Notifications.AddedToChannel.Enabled', '');
encodedParams.set('Notifications.AddedToChannel.Template', '');
encodedParams.set('Notifications.InvitedToChannel.Enabled', '');
encodedParams.set('Notifications.InvitedToChannel.Template', '');
encodedParams.set('Notifications.NewMessage.Enabled', '');
encodedParams.set('Notifications.NewMessage.Template', '');
encodedParams.set('Notifications.RemovedFromChannel.Enabled', '');
encodedParams.set('Notifications.RemovedFromChannel.Template', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('ReachabilityEnabled', '');
encodedParams.set('ReadStatusEnabled', '');
encodedParams.set('TypingIndicatorTimeout', '');
encodedParams.set('WebhookFilters', '');
encodedParams.set('WebhookMethod', '');
encodedParams.set('Webhooks.OnChannelAdd.Method', '');
encodedParams.set('Webhooks.OnChannelAdd.Url', '');
encodedParams.set('Webhooks.OnChannelAdded.Method', '');
encodedParams.set('Webhooks.OnChannelAdded.Url', '');
encodedParams.set('Webhooks.OnChannelDestroy.Method', '');
encodedParams.set('Webhooks.OnChannelDestroy.Url', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Method', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Url', '');
encodedParams.set('Webhooks.OnChannelUpdate.Method', '');
encodedParams.set('Webhooks.OnChannelUpdate.Url', '');
encodedParams.set('Webhooks.OnChannelUpdated.Method', '');
encodedParams.set('Webhooks.OnChannelUpdated.Url', '');
encodedParams.set('Webhooks.OnMemberAdd.Method', '');
encodedParams.set('Webhooks.OnMemberAdd.Url', '');
encodedParams.set('Webhooks.OnMemberAdded.Method', '');
encodedParams.set('Webhooks.OnMemberAdded.Url', '');
encodedParams.set('Webhooks.OnMemberRemove.Method', '');
encodedParams.set('Webhooks.OnMemberRemove.Url', '');
encodedParams.set('Webhooks.OnMemberRemoved.Method', '');
encodedParams.set('Webhooks.OnMemberRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageRemove.Method', '');
encodedParams.set('Webhooks.OnMessageRemove.Url', '');
encodedParams.set('Webhooks.OnMessageRemoved.Method', '');
encodedParams.set('Webhooks.OnMessageRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageSend.Method', '');
encodedParams.set('Webhooks.OnMessageSend.Url', '');
encodedParams.set('Webhooks.OnMessageSent.Method', '');
encodedParams.set('Webhooks.OnMessageSent.Url', '');
encodedParams.set('Webhooks.OnMessageUpdate.Method', '');
encodedParams.set('Webhooks.OnMessageUpdate.Url', '');
encodedParams.set('Webhooks.OnMessageUpdated.Method', '');
encodedParams.set('Webhooks.OnMessageUpdated.Url', '');

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('ConsumptionReportInterval', '');
encodedParams.set('DefaultChannelCreatorRoleSid', '');
encodedParams.set('DefaultChannelRoleSid', '');
encodedParams.set('DefaultServiceRoleSid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Limits.ChannelMembers', '');
encodedParams.set('Limits.UserChannels', '');
encodedParams.set('Notifications.AddedToChannel.Enabled', '');
encodedParams.set('Notifications.AddedToChannel.Template', '');
encodedParams.set('Notifications.InvitedToChannel.Enabled', '');
encodedParams.set('Notifications.InvitedToChannel.Template', '');
encodedParams.set('Notifications.NewMessage.Enabled', '');
encodedParams.set('Notifications.NewMessage.Template', '');
encodedParams.set('Notifications.RemovedFromChannel.Enabled', '');
encodedParams.set('Notifications.RemovedFromChannel.Template', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('ReachabilityEnabled', '');
encodedParams.set('ReadStatusEnabled', '');
encodedParams.set('TypingIndicatorTimeout', '');
encodedParams.set('WebhookFilters', '');
encodedParams.set('WebhookMethod', '');
encodedParams.set('Webhooks.OnChannelAdd.Method', '');
encodedParams.set('Webhooks.OnChannelAdd.Url', '');
encodedParams.set('Webhooks.OnChannelAdded.Method', '');
encodedParams.set('Webhooks.OnChannelAdded.Url', '');
encodedParams.set('Webhooks.OnChannelDestroy.Method', '');
encodedParams.set('Webhooks.OnChannelDestroy.Url', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Method', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Url', '');
encodedParams.set('Webhooks.OnChannelUpdate.Method', '');
encodedParams.set('Webhooks.OnChannelUpdate.Url', '');
encodedParams.set('Webhooks.OnChannelUpdated.Method', '');
encodedParams.set('Webhooks.OnChannelUpdated.Url', '');
encodedParams.set('Webhooks.OnMemberAdd.Method', '');
encodedParams.set('Webhooks.OnMemberAdd.Url', '');
encodedParams.set('Webhooks.OnMemberAdded.Method', '');
encodedParams.set('Webhooks.OnMemberAdded.Url', '');
encodedParams.set('Webhooks.OnMemberRemove.Method', '');
encodedParams.set('Webhooks.OnMemberRemove.Url', '');
encodedParams.set('Webhooks.OnMemberRemoved.Method', '');
encodedParams.set('Webhooks.OnMemberRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageRemove.Method', '');
encodedParams.set('Webhooks.OnMessageRemove.Url', '');
encodedParams.set('Webhooks.OnMessageRemoved.Method', '');
encodedParams.set('Webhooks.OnMessageRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageSend.Method', '');
encodedParams.set('Webhooks.OnMessageSend.Url', '');
encodedParams.set('Webhooks.OnMessageSent.Method', '');
encodedParams.set('Webhooks.OnMessageSent.Url', '');
encodedParams.set('Webhooks.OnMessageUpdate.Method', '');
encodedParams.set('Webhooks.OnMessageUpdate.Url', '');
encodedParams.set('Webhooks.OnMessageUpdated.Method', '');
encodedParams.set('Webhooks.OnMessageUpdated.Url', '');

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:[@"ConsumptionReportInterval=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultChannelCreatorRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultChannelRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultServiceRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Limits.ChannelMembers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Limits.UserChannels=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.AddedToChannel.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.AddedToChannel.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.InvitedToChannel.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.InvitedToChannel.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.NewMessage.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.NewMessage.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.RemovedFromChannel.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.RemovedFromChannel.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PostWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PreWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ReachabilityEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ReadStatusEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TypingIndicatorTimeout=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&WebhookFilters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&WebhookMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdd.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdd.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdded.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdded.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroy.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroy.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroyed.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroyed.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdate.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdate.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdated.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdated.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdd.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdd.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdded.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdded.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemove.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemove.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemoved.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemoved.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemove.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemove.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemoved.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemoved.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSend.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSend.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSent.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSent.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdate.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdate.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdated.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdated.Url=" 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 "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=" 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 => "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=",
  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' => [
    'ConsumptionReportInterval' => '',
    'DefaultChannelCreatorRoleSid' => '',
    'DefaultChannelRoleSid' => '',
    'DefaultServiceRoleSid' => '',
    'FriendlyName' => '',
    'Limits.ChannelMembers' => '',
    'Limits.UserChannels' => '',
    'Notifications.AddedToChannel.Enabled' => '',
    'Notifications.AddedToChannel.Template' => '',
    'Notifications.InvitedToChannel.Enabled' => '',
    'Notifications.InvitedToChannel.Template' => '',
    'Notifications.NewMessage.Enabled' => '',
    'Notifications.NewMessage.Template' => '',
    'Notifications.RemovedFromChannel.Enabled' => '',
    'Notifications.RemovedFromChannel.Template' => '',
    'PostWebhookUrl' => '',
    'PreWebhookUrl' => '',
    'ReachabilityEnabled' => '',
    'ReadStatusEnabled' => '',
    'TypingIndicatorTimeout' => '',
    'WebhookFilters' => '',
    'WebhookMethod' => '',
    'Webhooks.OnChannelAdd.Method' => '',
    'Webhooks.OnChannelAdd.Url' => '',
    'Webhooks.OnChannelAdded.Method' => '',
    'Webhooks.OnChannelAdded.Url' => '',
    'Webhooks.OnChannelDestroy.Method' => '',
    'Webhooks.OnChannelDestroy.Url' => '',
    'Webhooks.OnChannelDestroyed.Method' => '',
    'Webhooks.OnChannelDestroyed.Url' => '',
    'Webhooks.OnChannelUpdate.Method' => '',
    'Webhooks.OnChannelUpdate.Url' => '',
    'Webhooks.OnChannelUpdated.Method' => '',
    'Webhooks.OnChannelUpdated.Url' => '',
    'Webhooks.OnMemberAdd.Method' => '',
    'Webhooks.OnMemberAdd.Url' => '',
    'Webhooks.OnMemberAdded.Method' => '',
    'Webhooks.OnMemberAdded.Url' => '',
    'Webhooks.OnMemberRemove.Method' => '',
    'Webhooks.OnMemberRemove.Url' => '',
    'Webhooks.OnMemberRemoved.Method' => '',
    'Webhooks.OnMemberRemoved.Url' => '',
    'Webhooks.OnMessageRemove.Method' => '',
    'Webhooks.OnMessageRemove.Url' => '',
    'Webhooks.OnMessageRemoved.Method' => '',
    'Webhooks.OnMessageRemoved.Url' => '',
    'Webhooks.OnMessageSend.Method' => '',
    'Webhooks.OnMessageSend.Url' => '',
    'Webhooks.OnMessageSent.Method' => '',
    'Webhooks.OnMessageSent.Url' => '',
    'Webhooks.OnMessageUpdate.Method' => '',
    'Webhooks.OnMessageUpdate.Url' => '',
    'Webhooks.OnMessageUpdated.Method' => '',
    'Webhooks.OnMessageUpdated.Url' => ''
  ],
  '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([
  'ConsumptionReportInterval' => '',
  'DefaultChannelCreatorRoleSid' => '',
  'DefaultChannelRoleSid' => '',
  'DefaultServiceRoleSid' => '',
  'FriendlyName' => '',
  'Limits.ChannelMembers' => '',
  'Limits.UserChannels' => '',
  'Notifications.AddedToChannel.Enabled' => '',
  'Notifications.AddedToChannel.Template' => '',
  'Notifications.InvitedToChannel.Enabled' => '',
  'Notifications.InvitedToChannel.Template' => '',
  'Notifications.NewMessage.Enabled' => '',
  'Notifications.NewMessage.Template' => '',
  'Notifications.RemovedFromChannel.Enabled' => '',
  'Notifications.RemovedFromChannel.Template' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => '',
  'ReachabilityEnabled' => '',
  'ReadStatusEnabled' => '',
  'TypingIndicatorTimeout' => '',
  'WebhookFilters' => '',
  'WebhookMethod' => '',
  'Webhooks.OnChannelAdd.Method' => '',
  'Webhooks.OnChannelAdd.Url' => '',
  'Webhooks.OnChannelAdded.Method' => '',
  'Webhooks.OnChannelAdded.Url' => '',
  'Webhooks.OnChannelDestroy.Method' => '',
  'Webhooks.OnChannelDestroy.Url' => '',
  'Webhooks.OnChannelDestroyed.Method' => '',
  'Webhooks.OnChannelDestroyed.Url' => '',
  'Webhooks.OnChannelUpdate.Method' => '',
  'Webhooks.OnChannelUpdate.Url' => '',
  'Webhooks.OnChannelUpdated.Method' => '',
  'Webhooks.OnChannelUpdated.Url' => '',
  'Webhooks.OnMemberAdd.Method' => '',
  'Webhooks.OnMemberAdd.Url' => '',
  'Webhooks.OnMemberAdded.Method' => '',
  'Webhooks.OnMemberAdded.Url' => '',
  'Webhooks.OnMemberRemove.Method' => '',
  'Webhooks.OnMemberRemove.Url' => '',
  'Webhooks.OnMemberRemoved.Method' => '',
  'Webhooks.OnMemberRemoved.Url' => '',
  'Webhooks.OnMessageRemove.Method' => '',
  'Webhooks.OnMessageRemove.Url' => '',
  'Webhooks.OnMessageRemoved.Method' => '',
  'Webhooks.OnMessageRemoved.Url' => '',
  'Webhooks.OnMessageSend.Method' => '',
  'Webhooks.OnMessageSend.Url' => '',
  'Webhooks.OnMessageSent.Method' => '',
  'Webhooks.OnMessageSent.Url' => '',
  'Webhooks.OnMessageUpdate.Method' => '',
  'Webhooks.OnMessageUpdate.Url' => '',
  'Webhooks.OnMessageUpdated.Method' => '',
  'Webhooks.OnMessageUpdated.Url' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ConsumptionReportInterval' => '',
  'DefaultChannelCreatorRoleSid' => '',
  'DefaultChannelRoleSid' => '',
  'DefaultServiceRoleSid' => '',
  'FriendlyName' => '',
  'Limits.ChannelMembers' => '',
  'Limits.UserChannels' => '',
  'Notifications.AddedToChannel.Enabled' => '',
  'Notifications.AddedToChannel.Template' => '',
  'Notifications.InvitedToChannel.Enabled' => '',
  'Notifications.InvitedToChannel.Template' => '',
  'Notifications.NewMessage.Enabled' => '',
  'Notifications.NewMessage.Template' => '',
  'Notifications.RemovedFromChannel.Enabled' => '',
  'Notifications.RemovedFromChannel.Template' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => '',
  'ReachabilityEnabled' => '',
  'ReadStatusEnabled' => '',
  'TypingIndicatorTimeout' => '',
  'WebhookFilters' => '',
  'WebhookMethod' => '',
  'Webhooks.OnChannelAdd.Method' => '',
  'Webhooks.OnChannelAdd.Url' => '',
  'Webhooks.OnChannelAdded.Method' => '',
  'Webhooks.OnChannelAdded.Url' => '',
  'Webhooks.OnChannelDestroy.Method' => '',
  'Webhooks.OnChannelDestroy.Url' => '',
  'Webhooks.OnChannelDestroyed.Method' => '',
  'Webhooks.OnChannelDestroyed.Url' => '',
  'Webhooks.OnChannelUpdate.Method' => '',
  'Webhooks.OnChannelUpdate.Url' => '',
  'Webhooks.OnChannelUpdated.Method' => '',
  'Webhooks.OnChannelUpdated.Url' => '',
  'Webhooks.OnMemberAdd.Method' => '',
  'Webhooks.OnMemberAdd.Url' => '',
  'Webhooks.OnMemberAdded.Method' => '',
  'Webhooks.OnMemberAdded.Url' => '',
  'Webhooks.OnMemberRemove.Method' => '',
  'Webhooks.OnMemberRemove.Url' => '',
  'Webhooks.OnMemberRemoved.Method' => '',
  'Webhooks.OnMemberRemoved.Url' => '',
  'Webhooks.OnMessageRemove.Method' => '',
  'Webhooks.OnMessageRemove.Url' => '',
  'Webhooks.OnMessageRemoved.Method' => '',
  'Webhooks.OnMessageRemoved.Url' => '',
  'Webhooks.OnMessageSend.Method' => '',
  'Webhooks.OnMessageSend.Url' => '',
  'Webhooks.OnMessageSent.Method' => '',
  'Webhooks.OnMessageSent.Url' => '',
  'Webhooks.OnMessageUpdate.Method' => '',
  'Webhooks.OnMessageUpdate.Url' => '',
  'Webhooks.OnMessageUpdated.Method' => '',
  'Webhooks.OnMessageUpdated.Url' => ''
]));

$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 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url='

$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 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="

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 = {
    "ConsumptionReportInterval": "",
    "DefaultChannelCreatorRoleSid": "",
    "DefaultChannelRoleSid": "",
    "DefaultServiceRoleSid": "",
    "FriendlyName": "",
    "Limits.ChannelMembers": "",
    "Limits.UserChannels": "",
    "Notifications.AddedToChannel.Enabled": "",
    "Notifications.AddedToChannel.Template": "",
    "Notifications.InvitedToChannel.Enabled": "",
    "Notifications.InvitedToChannel.Template": "",
    "Notifications.NewMessage.Enabled": "",
    "Notifications.NewMessage.Template": "",
    "Notifications.RemovedFromChannel.Enabled": "",
    "Notifications.RemovedFromChannel.Template": "",
    "PostWebhookUrl": "",
    "PreWebhookUrl": "",
    "ReachabilityEnabled": "",
    "ReadStatusEnabled": "",
    "TypingIndicatorTimeout": "",
    "WebhookFilters": "",
    "WebhookMethod": "",
    "Webhooks.OnChannelAdd.Method": "",
    "Webhooks.OnChannelAdd.Url": "",
    "Webhooks.OnChannelAdded.Method": "",
    "Webhooks.OnChannelAdded.Url": "",
    "Webhooks.OnChannelDestroy.Method": "",
    "Webhooks.OnChannelDestroy.Url": "",
    "Webhooks.OnChannelDestroyed.Method": "",
    "Webhooks.OnChannelDestroyed.Url": "",
    "Webhooks.OnChannelUpdate.Method": "",
    "Webhooks.OnChannelUpdate.Url": "",
    "Webhooks.OnChannelUpdated.Method": "",
    "Webhooks.OnChannelUpdated.Url": "",
    "Webhooks.OnMemberAdd.Method": "",
    "Webhooks.OnMemberAdd.Url": "",
    "Webhooks.OnMemberAdded.Method": "",
    "Webhooks.OnMemberAdded.Url": "",
    "Webhooks.OnMemberRemove.Method": "",
    "Webhooks.OnMemberRemove.Url": "",
    "Webhooks.OnMemberRemoved.Method": "",
    "Webhooks.OnMemberRemoved.Url": "",
    "Webhooks.OnMessageRemove.Method": "",
    "Webhooks.OnMessageRemove.Url": "",
    "Webhooks.OnMessageRemoved.Method": "",
    "Webhooks.OnMessageRemoved.Url": "",
    "Webhooks.OnMessageSend.Method": "",
    "Webhooks.OnMessageSend.Url": "",
    "Webhooks.OnMessageSent.Method": "",
    "Webhooks.OnMessageSent.Url": "",
    "Webhooks.OnMessageUpdate.Method": "",
    "Webhooks.OnMessageUpdate.Url": "",
    "Webhooks.OnMessageUpdated.Method": "",
    "Webhooks.OnMessageUpdated.Url": ""
}
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 <- "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="

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 = "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :ConsumptionReportInterval => "",
  :DefaultChannelCreatorRoleSid => "",
  :DefaultChannelRoleSid => "",
  :DefaultServiceRoleSid => "",
  :FriendlyName => "",
  :Limits.ChannelMembers => "",
  :Limits.UserChannels => "",
  :Notifications.AddedToChannel.Enabled => "",
  :Notifications.AddedToChannel.Template => "",
  :Notifications.InvitedToChannel.Enabled => "",
  :Notifications.InvitedToChannel.Template => "",
  :Notifications.NewMessage.Enabled => "",
  :Notifications.NewMessage.Template => "",
  :Notifications.RemovedFromChannel.Enabled => "",
  :Notifications.RemovedFromChannel.Template => "",
  :PostWebhookUrl => "",
  :PreWebhookUrl => "",
  :ReachabilityEnabled => "",
  :ReadStatusEnabled => "",
  :TypingIndicatorTimeout => "",
  :WebhookFilters => "",
  :WebhookMethod => "",
  :Webhooks.OnChannelAdd.Method => "",
  :Webhooks.OnChannelAdd.Url => "",
  :Webhooks.OnChannelAdded.Method => "",
  :Webhooks.OnChannelAdded.Url => "",
  :Webhooks.OnChannelDestroy.Method => "",
  :Webhooks.OnChannelDestroy.Url => "",
  :Webhooks.OnChannelDestroyed.Method => "",
  :Webhooks.OnChannelDestroyed.Url => "",
  :Webhooks.OnChannelUpdate.Method => "",
  :Webhooks.OnChannelUpdate.Url => "",
  :Webhooks.OnChannelUpdated.Method => "",
  :Webhooks.OnChannelUpdated.Url => "",
  :Webhooks.OnMemberAdd.Method => "",
  :Webhooks.OnMemberAdd.Url => "",
  :Webhooks.OnMemberAdded.Method => "",
  :Webhooks.OnMemberAdded.Url => "",
  :Webhooks.OnMemberRemove.Method => "",
  :Webhooks.OnMemberRemove.Url => "",
  :Webhooks.OnMemberRemoved.Method => "",
  :Webhooks.OnMemberRemoved.Url => "",
  :Webhooks.OnMessageRemove.Method => "",
  :Webhooks.OnMessageRemove.Url => "",
  :Webhooks.OnMessageRemoved.Method => "",
  :Webhooks.OnMessageRemoved.Url => "",
  :Webhooks.OnMessageSend.Method => "",
  :Webhooks.OnMessageSend.Url => "",
  :Webhooks.OnMessageSent.Method => "",
  :Webhooks.OnMessageSent.Url => "",
  :Webhooks.OnMessageUpdate.Method => "",
  :Webhooks.OnMessageUpdate.Url => "",
  :Webhooks.OnMessageUpdated.Method => "",
  :Webhooks.OnMessageUpdated.Url => "",
}

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!({
        "ConsumptionReportInterval": "",
        "DefaultChannelCreatorRoleSid": "",
        "DefaultChannelRoleSid": "",
        "DefaultServiceRoleSid": "",
        "FriendlyName": "",
        "Limits.ChannelMembers": "",
        "Limits.UserChannels": "",
        "Notifications.AddedToChannel.Enabled": "",
        "Notifications.AddedToChannel.Template": "",
        "Notifications.InvitedToChannel.Enabled": "",
        "Notifications.InvitedToChannel.Template": "",
        "Notifications.NewMessage.Enabled": "",
        "Notifications.NewMessage.Template": "",
        "Notifications.RemovedFromChannel.Enabled": "",
        "Notifications.RemovedFromChannel.Template": "",
        "PostWebhookUrl": "",
        "PreWebhookUrl": "",
        "ReachabilityEnabled": "",
        "ReadStatusEnabled": "",
        "TypingIndicatorTimeout": "",
        "WebhookFilters": "",
        "WebhookMethod": "",
        "Webhooks.OnChannelAdd.Method": "",
        "Webhooks.OnChannelAdd.Url": "",
        "Webhooks.OnChannelAdded.Method": "",
        "Webhooks.OnChannelAdded.Url": "",
        "Webhooks.OnChannelDestroy.Method": "",
        "Webhooks.OnChannelDestroy.Url": "",
        "Webhooks.OnChannelDestroyed.Method": "",
        "Webhooks.OnChannelDestroyed.Url": "",
        "Webhooks.OnChannelUpdate.Method": "",
        "Webhooks.OnChannelUpdate.Url": "",
        "Webhooks.OnChannelUpdated.Method": "",
        "Webhooks.OnChannelUpdated.Url": "",
        "Webhooks.OnMemberAdd.Method": "",
        "Webhooks.OnMemberAdd.Url": "",
        "Webhooks.OnMemberAdded.Method": "",
        "Webhooks.OnMemberAdded.Url": "",
        "Webhooks.OnMemberRemove.Method": "",
        "Webhooks.OnMemberRemove.Url": "",
        "Webhooks.OnMemberRemoved.Method": "",
        "Webhooks.OnMemberRemoved.Url": "",
        "Webhooks.OnMessageRemove.Method": "",
        "Webhooks.OnMessageRemove.Url": "",
        "Webhooks.OnMessageRemoved.Method": "",
        "Webhooks.OnMessageRemoved.Url": "",
        "Webhooks.OnMessageSend.Method": "",
        "Webhooks.OnMessageSend.Url": "",
        "Webhooks.OnMessageSent.Method": "",
        "Webhooks.OnMessageSent.Url": "",
        "Webhooks.OnMessageUpdate.Method": "",
        "Webhooks.OnMessageUpdate.Url": "",
        "Webhooks.OnMessageUpdated.Method": "",
        "Webhooks.OnMessageUpdated.Url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:Sid \
  content-type:application/x-www-form-urlencoded \
  ConsumptionReportInterval='' \
  DefaultChannelCreatorRoleSid='' \
  DefaultChannelRoleSid='' \
  DefaultServiceRoleSid='' \
  FriendlyName='' \
  Limits.ChannelMembers='' \
  Limits.UserChannels='' \
  Notifications.AddedToChannel.Enabled='' \
  Notifications.AddedToChannel.Template='' \
  Notifications.InvitedToChannel.Enabled='' \
  Notifications.InvitedToChannel.Template='' \
  Notifications.NewMessage.Enabled='' \
  Notifications.NewMessage.Template='' \
  Notifications.RemovedFromChannel.Enabled='' \
  Notifications.RemovedFromChannel.Template='' \
  PostWebhookUrl='' \
  PreWebhookUrl='' \
  ReachabilityEnabled='' \
  ReadStatusEnabled='' \
  TypingIndicatorTimeout='' \
  WebhookFilters='' \
  WebhookMethod='' \
  Webhooks.OnChannelAdd.Method='' \
  Webhooks.OnChannelAdd.Url='' \
  Webhooks.OnChannelAdded.Method='' \
  Webhooks.OnChannelAdded.Url='' \
  Webhooks.OnChannelDestroy.Method='' \
  Webhooks.OnChannelDestroy.Url='' \
  Webhooks.OnChannelDestroyed.Method='' \
  Webhooks.OnChannelDestroyed.Url='' \
  Webhooks.OnChannelUpdate.Method='' \
  Webhooks.OnChannelUpdate.Url='' \
  Webhooks.OnChannelUpdated.Method='' \
  Webhooks.OnChannelUpdated.Url='' \
  Webhooks.OnMemberAdd.Method='' \
  Webhooks.OnMemberAdd.Url='' \
  Webhooks.OnMemberAdded.Method='' \
  Webhooks.OnMemberAdded.Url='' \
  Webhooks.OnMemberRemove.Method='' \
  Webhooks.OnMemberRemove.Url='' \
  Webhooks.OnMemberRemoved.Method='' \
  Webhooks.OnMemberRemoved.Url='' \
  Webhooks.OnMessageRemove.Method='' \
  Webhooks.OnMessageRemove.Url='' \
  Webhooks.OnMessageRemoved.Method='' \
  Webhooks.OnMessageRemoved.Url='' \
  Webhooks.OnMessageSend.Method='' \
  Webhooks.OnMessageSend.Url='' \
  Webhooks.OnMessageSent.Method='' \
  Webhooks.OnMessageSent.Url='' \
  Webhooks.OnMessageUpdate.Method='' \
  Webhooks.OnMessageUpdate.Url='' \
  Webhooks.OnMessageUpdated.Method='' \
  Webhooks.OnMessageUpdated.Url=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ConsumptionReportInterval=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultChannelCreatorRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultChannelRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultServiceRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Limits.ChannelMembers=".data(using: String.Encoding.utf8)!)
postData.append("&Limits.UserChannels=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.AddedToChannel.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.AddedToChannel.Template=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.InvitedToChannel.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.InvitedToChannel.Template=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.NewMessage.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.NewMessage.Template=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.RemovedFromChannel.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.RemovedFromChannel.Template=".data(using: String.Encoding.utf8)!)
postData.append("&PostWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&PreWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&ReachabilityEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&ReadStatusEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&TypingIndicatorTimeout=".data(using: String.Encoding.utf8)!)
postData.append("&WebhookFilters=".data(using: String.Encoding.utf8)!)
postData.append("&WebhookMethod=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdd.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdd.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdded.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdded.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroy.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroy.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroyed.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroyed.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdate.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdate.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdated.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdated.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdd.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdd.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdded.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdded.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemove.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemove.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemoved.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemoved.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemove.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemove.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemoved.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemoved.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSend.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSend.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSent.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSent.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdate.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdate.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdated.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdated.Url=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users/: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, "Attributes=&FriendlyName=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid" {:form-params {:Attributes ""
                                                                                             :FriendlyName ""
                                                                                             :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&RoleSid="

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/Users/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "RoleSid", "" },
    }),
};
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/Users/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

	payload := strings.NewReader("Attributes=&FriendlyName=&RoleSid=")

	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/Users/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 34

Attributes=&FriendlyName=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&FriendlyName=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&RoleSid="))
    .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, "Attributes=&FriendlyName=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&RoleSid=")
  .asString();

const data = 'Attributes=&FriendlyName=&RoleSid=';

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/Users/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', RoleSid: ''})
};

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/Users/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    RoleSid: ''
  }
};

$.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, "Attributes=&FriendlyName=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/: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({Attributes: '', FriendlyName: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', RoleSid: ''}
};

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/Users/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  FriendlyName: '',
  RoleSid: ''
});

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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/: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('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Users/: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:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&RoleSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ServiceSid/Users/: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 => "Attributes=&FriendlyName=&RoleSid=",
  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/Users/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'FriendlyName' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/: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/Users/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&FriendlyName=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Users/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "RoleSid": ""
}
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/Users/:Sid"

payload <- "Attributes=&FriendlyName=&RoleSid="

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/Users/: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 = "Attributes=&FriendlyName=&RoleSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Users/: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/Users/:Sid";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Users/: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()