CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities");

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, "Available=&FriendlyName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities" {:form-params {:Available ""
                                                                                                 :FriendlyName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"

	payload := strings.NewReader("Available=&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/Workspaces/:WorkspaceSid/Activities HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 24

Available=&FriendlyName=

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Available=&FriendlyName=")
  .asString();

const data = 'Available=&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/Workspaces/:WorkspaceSid/Activities');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

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

const request = require('request');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities',
  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('Available', '');
encodedParams.set('FriendlyName', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities';
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:[@"Available=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities');
$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/Workspaces/:WorkspaceSid/Activities' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Available=&FriendlyName='

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

import http.client

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

payload = "Available=&FriendlyName="

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

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/Activities", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"

payload = {
    "Available": "",
    "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/Workspaces/:WorkspaceSid/Activities"

payload <- "Available=&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/Workspaces/:WorkspaceSid/Activities")

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 = "Available=&FriendlyName="

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

require 'faraday'

data = {
  :Available => "",
  :FriendlyName => "",
}

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

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

    let payload = json!({
        "Available": "",
        "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/Workspaces/:WorkspaceSid/Activities \
  content-type:application/x-www-form-urlencoded \
  Available='' \
  FriendlyName=''

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")! 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/Workspaces/:WorkspaceSid/Tasks");

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=&Priority=&TaskChannel=&Timeout=&WorkflowSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks" {:form-params {:Attributes ""
                                                                                            :Priority ""
                                                                                            :TaskChannel ""
                                                                                            :Timeout ""
                                                                                            :WorkflowSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid="

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/Workspaces/:WorkspaceSid/Tasks"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Priority", "" },
        { "TaskChannel", "" },
        { "Timeout", "" },
        { "WorkflowSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

	payload := strings.NewReader("Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=")

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

Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid="))
    .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=&Priority=&TaskChannel=&Timeout=&WorkflowSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=")
  .asString();

const data = 'Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=';

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/Workspaces/:WorkspaceSid/Tasks');
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('Priority', '');
encodedParams.set('TaskChannel', '');
encodedParams.set('Timeout', '');
encodedParams.set('WorkflowSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks',
  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/Workspaces/:WorkspaceSid/Tasks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', Priority: '', TaskChannel: '', Timeout: '', WorkflowSid: ''})
};

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/Workspaces/:WorkspaceSid/Tasks',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Priority: '',
    TaskChannel: '',
    Timeout: '',
    WorkflowSid: ''
  }
};

$.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=&Priority=&TaskChannel=&Timeout=&WorkflowSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .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/Workspaces/:WorkspaceSid/Tasks',
  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: '', Priority: '', TaskChannel: '', Timeout: '', WorkflowSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Priority: '', TaskChannel: '', Timeout: '', WorkflowSid: ''}
};

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/Workspaces/:WorkspaceSid/Tasks');

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

req.form({
  Attributes: '',
  Priority: '',
  TaskChannel: '',
  Timeout: '',
  WorkflowSid: ''
});

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('Priority', '');
encodedParams.set('TaskChannel', '');
encodedParams.set('Timeout', '');
encodedParams.set('WorkflowSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks',
  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('Priority', '');
encodedParams.set('TaskChannel', '');
encodedParams.set('Timeout', '');
encodedParams.set('WorkflowSid', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks';
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:[@"&Priority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TaskChannel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timeout=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&WorkflowSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"]
                                                       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/Workspaces/:WorkspaceSid/Tasks" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks",
  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=&Priority=&TaskChannel=&Timeout=&WorkflowSid=",
  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/Workspaces/:WorkspaceSid/Tasks', [
  'form_params' => [
    'Attributes' => '',
    'Priority' => '',
    'TaskChannel' => '',
    'Timeout' => '',
    'WorkflowSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'Priority' => '',
  'TaskChannel' => '',
  'Timeout' => '',
  'WorkflowSid' => ''
]);

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

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

append(new http\QueryString([
  'Attributes' => '',
  'Priority' => '',
  'TaskChannel' => '',
  'Timeout' => '',
  'WorkflowSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks');
$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/Workspaces/:WorkspaceSid/Tasks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid='

import http.client

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

payload = "Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid="

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

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

payload = {
    "Attributes": "",
    "Priority": "",
    "TaskChannel": "",
    "Timeout": "",
    "WorkflowSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

payload <- "Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid="

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/Workspaces/:WorkspaceSid/Tasks")

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=&Priority=&TaskChannel=&Timeout=&WorkflowSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :Priority => "",
  :TaskChannel => "",
  :Timeout => "",
  :WorkflowSid => "",
}

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

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

    let payload = json!({
        "Attributes": "",
        "Priority": "",
        "TaskChannel": "",
        "Timeout": "",
        "WorkflowSid": ""
    });

    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/Workspaces/:WorkspaceSid/Tasks \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Priority='' \
  TaskChannel='' \
  Timeout='' \
  WorkflowSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Priority=&TaskChannel=&Timeout=&WorkflowSid=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks

import Foundation

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

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Priority=".data(using: String.Encoding.utf8)!)
postData.append("&TaskChannel=".data(using: String.Encoding.utf8)!)
postData.append("&Timeout=".data(using: String.Encoding.utf8)!)
postData.append("&WorkflowSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")! 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/Workspaces/:WorkspaceSid/TaskChannels");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels" {:form-params {:ChannelOptimizedRouting ""
                                                                                                   :FriendlyName ""
                                                                                                   :UniqueName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"

	payload := strings.NewReader("ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 50

ChannelOptimizedRouting=&FriendlyName=&UniqueName=

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChannelOptimizedRouting=&FriendlyName=&UniqueName=")
  .asString();

const data = 'ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

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

const request = require('request');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels',
  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('ChannelOptimizedRouting', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels';
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:[@"ChannelOptimizedRouting=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

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

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

import http.client

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

payload = "ChannelOptimizedRouting=&FriendlyName=&UniqueName="

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

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"

payload = {
    "ChannelOptimizedRouting": "",
    "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/Workspaces/:WorkspaceSid/TaskChannels"

payload <- "ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels")

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

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

require 'faraday'

data = {
  :ChannelOptimizedRouting => "",
  :FriendlyName => "",
  :UniqueName => "",
}

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

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

    let payload = json!({
        "ChannelOptimizedRouting": "",
        "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/Workspaces/:WorkspaceSid/TaskChannels \
  content-type:application/x-www-form-urlencoded \
  ChannelOptimizedRouting='' \
  FriendlyName='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChannelOptimizedRouting=&FriendlyName=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels

import Foundation

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

let postData = NSMutableData(data: "ChannelOptimizedRouting=".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/Workspaces/:WorkspaceSid/TaskChannels")! 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/Workspaces/:WorkspaceSid/TaskQueues");

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, "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues" {:form-params {:AssignmentActivitySid ""
                                                                                                 :FriendlyName ""
                                                                                                 :MaxReservedWorkers ""
                                                                                                 :ReservationActivitySid ""
                                                                                                 :TargetWorkers ""
                                                                                                 :TaskOrder ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="

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/Workspaces/:WorkspaceSid/TaskQueues"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AssignmentActivitySid", "" },
        { "FriendlyName", "" },
        { "MaxReservedWorkers", "" },
        { "ReservationActivitySid", "" },
        { "TargetWorkers", "" },
        { "TaskOrder", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

	payload := strings.NewReader("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")

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

AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="))
    .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, "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")
  .asString();

const data = 'AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AssignmentActivitySid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MaxReservedWorkers', '');
encodedParams.set('ReservationActivitySid', '');
encodedParams.set('TargetWorkers', '');
encodedParams.set('TaskOrder', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues',
  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/Workspaces/:WorkspaceSid/TaskQueues';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AssignmentActivitySid: '',
    FriendlyName: '',
    MaxReservedWorkers: '',
    ReservationActivitySid: '',
    TargetWorkers: '',
    TaskOrder: ''
  })
};

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/Workspaces/:WorkspaceSid/TaskQueues',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AssignmentActivitySid: '',
    FriendlyName: '',
    MaxReservedWorkers: '',
    ReservationActivitySid: '',
    TargetWorkers: '',
    TaskOrder: ''
  }
};

$.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, "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .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/Workspaces/:WorkspaceSid/TaskQueues',
  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({
  AssignmentActivitySid: '',
  FriendlyName: '',
  MaxReservedWorkers: '',
  ReservationActivitySid: '',
  TargetWorkers: '',
  TaskOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AssignmentActivitySid: '',
    FriendlyName: '',
    MaxReservedWorkers: '',
    ReservationActivitySid: '',
    TargetWorkers: '',
    TaskOrder: ''
  }
};

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/Workspaces/:WorkspaceSid/TaskQueues');

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

req.form({
  AssignmentActivitySid: '',
  FriendlyName: '',
  MaxReservedWorkers: '',
  ReservationActivitySid: '',
  TargetWorkers: '',
  TaskOrder: ''
});

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('AssignmentActivitySid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MaxReservedWorkers', '');
encodedParams.set('ReservationActivitySid', '');
encodedParams.set('TargetWorkers', '');
encodedParams.set('TaskOrder', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues',
  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('AssignmentActivitySid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MaxReservedWorkers', '');
encodedParams.set('ReservationActivitySid', '');
encodedParams.set('TargetWorkers', '');
encodedParams.set('TaskOrder', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues';
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:[@"AssignmentActivitySid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MaxReservedWorkers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ReservationActivitySid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TargetWorkers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TaskOrder=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"]
                                                       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/Workspaces/:WorkspaceSid/TaskQueues" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=",
  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/Workspaces/:WorkspaceSid/TaskQueues', [
  'form_params' => [
    'AssignmentActivitySid' => '',
    'FriendlyName' => '',
    'MaxReservedWorkers' => '',
    'ReservationActivitySid' => '',
    'TargetWorkers' => '',
    'TaskOrder' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AssignmentActivitySid' => '',
  'FriendlyName' => '',
  'MaxReservedWorkers' => '',
  'ReservationActivitySid' => '',
  'TargetWorkers' => '',
  'TaskOrder' => ''
]);

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

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

append(new http\QueryString([
  'AssignmentActivitySid' => '',
  'FriendlyName' => '',
  'MaxReservedWorkers' => '',
  'ReservationActivitySid' => '',
  'TargetWorkers' => '',
  'TaskOrder' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues');
$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/Workspaces/:WorkspaceSid/TaskQueues' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder='

import http.client

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

payload = "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="

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

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

payload = {
    "AssignmentActivitySid": "",
    "FriendlyName": "",
    "MaxReservedWorkers": "",
    "ReservationActivitySid": "",
    "TargetWorkers": "",
    "TaskOrder": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

payload <- "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="

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/Workspaces/:WorkspaceSid/TaskQueues")

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 = "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="

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

require 'faraday'

data = {
  :AssignmentActivitySid => "",
  :FriendlyName => "",
  :MaxReservedWorkers => "",
  :ReservationActivitySid => "",
  :TargetWorkers => "",
  :TaskOrder => "",
}

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

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

    let payload = json!({
        "AssignmentActivitySid": "",
        "FriendlyName": "",
        "MaxReservedWorkers": "",
        "ReservationActivitySid": "",
        "TargetWorkers": "",
        "TaskOrder": ""
    });

    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/Workspaces/:WorkspaceSid/TaskQueues \
  content-type:application/x-www-form-urlencoded \
  AssignmentActivitySid='' \
  FriendlyName='' \
  MaxReservedWorkers='' \
  ReservationActivitySid='' \
  TargetWorkers='' \
  TaskOrder=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues

import Foundation

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

let postData = NSMutableData(data: "AssignmentActivitySid=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&MaxReservedWorkers=".data(using: String.Encoding.utf8)!)
postData.append("&ReservationActivitySid=".data(using: String.Encoding.utf8)!)
postData.append("&TargetWorkers=".data(using: String.Encoding.utf8)!)
postData.append("&TaskOrder=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")! 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/Workspaces/:WorkspaceSid/Workers");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers" {:form-params {:ActivitySid ""
                                                                                              :Attributes ""
                                                                                              :FriendlyName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"

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

ActivitySid=&Attributes=&FriendlyName=

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ActivitySid=&Attributes=&FriendlyName=")
  .asString();

const data = 'ActivitySid=&Attributes=&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/Workspaces/:WorkspaceSid/Workers');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

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

const request = require('request');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers',
  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('ActivitySid', '');
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers';
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:[@"ActivitySid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

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

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

import http.client

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

payload = "ActivitySid=&Attributes=&FriendlyName="

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

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"

payload = {
    "ActivitySid": "",
    "Attributes": "",
    "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/Workspaces/:WorkspaceSid/Workers"

payload <- "ActivitySid=&Attributes=&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/Workspaces/:WorkspaceSid/Workers")

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

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

require 'faraday'

data = {
  :ActivitySid => "",
  :Attributes => "",
  :FriendlyName => "",
}

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

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

    let payload = json!({
        "ActivitySid": "",
        "Attributes": "",
        "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/Workspaces/:WorkspaceSid/Workers \
  content-type:application/x-www-form-urlencoded \
  ActivitySid='' \
  Attributes='' \
  FriendlyName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ActivitySid=&Attributes=&FriendlyName=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")! 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/Workspaces/:WorkspaceSid/Workflows");

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, "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows" {:form-params {:AssignmentCallbackUrl ""
                                                                                                :Configuration ""
                                                                                                :FallbackAssignmentCallbackUrl ""
                                                                                                :FriendlyName ""
                                                                                                :TaskReservationTimeout ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout="

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/Workspaces/:WorkspaceSid/Workflows"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AssignmentCallbackUrl", "" },
        { "Configuration", "" },
        { "FallbackAssignmentCallbackUrl", "" },
        { "FriendlyName", "" },
        { "TaskReservationTimeout", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

	payload := strings.NewReader("AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=")

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

AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout="))
    .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, "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=")
  .asString();

const data = 'AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AssignmentCallbackUrl', '');
encodedParams.set('Configuration', '');
encodedParams.set('FallbackAssignmentCallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('TaskReservationTimeout', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows',
  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/Workspaces/:WorkspaceSid/Workflows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AssignmentCallbackUrl: '',
    Configuration: '',
    FallbackAssignmentCallbackUrl: '',
    FriendlyName: '',
    TaskReservationTimeout: ''
  })
};

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/Workspaces/:WorkspaceSid/Workflows',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AssignmentCallbackUrl: '',
    Configuration: '',
    FallbackAssignmentCallbackUrl: '',
    FriendlyName: '',
    TaskReservationTimeout: ''
  }
};

$.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, "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .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/Workspaces/:WorkspaceSid/Workflows',
  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({
  AssignmentCallbackUrl: '',
  Configuration: '',
  FallbackAssignmentCallbackUrl: '',
  FriendlyName: '',
  TaskReservationTimeout: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AssignmentCallbackUrl: '',
    Configuration: '',
    FallbackAssignmentCallbackUrl: '',
    FriendlyName: '',
    TaskReservationTimeout: ''
  }
};

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/Workspaces/:WorkspaceSid/Workflows');

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

req.form({
  AssignmentCallbackUrl: '',
  Configuration: '',
  FallbackAssignmentCallbackUrl: '',
  FriendlyName: '',
  TaskReservationTimeout: ''
});

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('AssignmentCallbackUrl', '');
encodedParams.set('Configuration', '');
encodedParams.set('FallbackAssignmentCallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('TaskReservationTimeout', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows',
  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('AssignmentCallbackUrl', '');
encodedParams.set('Configuration', '');
encodedParams.set('FallbackAssignmentCallbackUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('TaskReservationTimeout', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows';
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:[@"AssignmentCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FallbackAssignmentCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TaskReservationTimeout=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"]
                                                       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/Workspaces/:WorkspaceSid/Workflows" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=",
  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/Workspaces/:WorkspaceSid/Workflows', [
  'form_params' => [
    'AssignmentCallbackUrl' => '',
    'Configuration' => '',
    'FallbackAssignmentCallbackUrl' => '',
    'FriendlyName' => '',
    'TaskReservationTimeout' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AssignmentCallbackUrl' => '',
  'Configuration' => '',
  'FallbackAssignmentCallbackUrl' => '',
  'FriendlyName' => '',
  'TaskReservationTimeout' => ''
]);

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

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

append(new http\QueryString([
  'AssignmentCallbackUrl' => '',
  'Configuration' => '',
  'FallbackAssignmentCallbackUrl' => '',
  'FriendlyName' => '',
  'TaskReservationTimeout' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows');
$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/Workspaces/:WorkspaceSid/Workflows' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout='

import http.client

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

payload = "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout="

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

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

payload = {
    "AssignmentCallbackUrl": "",
    "Configuration": "",
    "FallbackAssignmentCallbackUrl": "",
    "FriendlyName": "",
    "TaskReservationTimeout": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

payload <- "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout="

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/Workspaces/:WorkspaceSid/Workflows")

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 = "AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout="

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

require 'faraday'

data = {
  :AssignmentCallbackUrl => "",
  :Configuration => "",
  :FallbackAssignmentCallbackUrl => "",
  :FriendlyName => "",
  :TaskReservationTimeout => "",
}

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

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

    let payload = json!({
        "AssignmentCallbackUrl": "",
        "Configuration": "",
        "FallbackAssignmentCallbackUrl": "",
        "FriendlyName": "",
        "TaskReservationTimeout": ""
    });

    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/Workspaces/:WorkspaceSid/Workflows \
  content-type:application/x-www-form-urlencoded \
  AssignmentCallbackUrl='' \
  Configuration='' \
  FallbackAssignmentCallbackUrl='' \
  FriendlyName='' \
  TaskReservationTimeout=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AssignmentCallbackUrl=&Configuration=&FallbackAssignmentCallbackUrl=&FriendlyName=&TaskReservationTimeout=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows

import Foundation

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

let postData = NSMutableData(data: "AssignmentCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration=".data(using: String.Encoding.utf8)!)
postData.append("&FallbackAssignmentCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&TaskReservationTimeout=".data(using: String.Encoding.utf8)!)

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

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, "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Workspaces" {:form-params {:EventCallbackUrl ""
                                                                        :EventsFilter ""
                                                                        :FriendlyName ""
                                                                        :MultiTaskEnabled ""
                                                                        :PrioritizeQueueOrder ""
                                                                        :Template ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template="

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/Workspaces"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "EventCallbackUrl", "" },
        { "EventsFilter", "" },
        { "FriendlyName", "" },
        { "MultiTaskEnabled", "" },
        { "PrioritizeQueueOrder", "" },
        { "Template", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=")

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

EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=")
  .asString();

const data = 'EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('EventCallbackUrl', '');
encodedParams.set('EventsFilter', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MultiTaskEnabled', '');
encodedParams.set('PrioritizeQueueOrder', '');
encodedParams.set('Template', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces',
  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/Workspaces';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    EventCallbackUrl: '',
    EventsFilter: '',
    FriendlyName: '',
    MultiTaskEnabled: '',
    PrioritizeQueueOrder: '',
    Template: ''
  })
};

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/Workspaces',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    EventCallbackUrl: '',
    EventsFilter: '',
    FriendlyName: '',
    MultiTaskEnabled: '',
    PrioritizeQueueOrder: '',
    Template: ''
  }
};

$.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, "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces")
  .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/Workspaces',
  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({
  EventCallbackUrl: '',
  EventsFilter: '',
  FriendlyName: '',
  MultiTaskEnabled: '',
  PrioritizeQueueOrder: '',
  Template: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    EventCallbackUrl: '',
    EventsFilter: '',
    FriendlyName: '',
    MultiTaskEnabled: '',
    PrioritizeQueueOrder: '',
    Template: ''
  }
};

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

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

req.form({
  EventCallbackUrl: '',
  EventsFilter: '',
  FriendlyName: '',
  MultiTaskEnabled: '',
  PrioritizeQueueOrder: '',
  Template: ''
});

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('EventCallbackUrl', '');
encodedParams.set('EventsFilter', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MultiTaskEnabled', '');
encodedParams.set('PrioritizeQueueOrder', '');
encodedParams.set('Template', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces',
  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('EventCallbackUrl', '');
encodedParams.set('EventsFilter', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MultiTaskEnabled', '');
encodedParams.set('PrioritizeQueueOrder', '');
encodedParams.set('Template', '');

const url = '{{baseUrl}}/v1/Workspaces';
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:[@"EventCallbackUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&EventsFilter=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MultiTaskEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PrioritizeQueueOrder=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Template=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/Workspaces",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=",
  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/Workspaces', [
  'form_params' => [
    'EventCallbackUrl' => '',
    'EventsFilter' => '',
    'FriendlyName' => '',
    'MultiTaskEnabled' => '',
    'PrioritizeQueueOrder' => '',
    'Template' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'EventCallbackUrl' => '',
  'EventsFilter' => '',
  'FriendlyName' => '',
  'MultiTaskEnabled' => '',
  'PrioritizeQueueOrder' => '',
  'Template' => ''
]);

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

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

append(new http\QueryString([
  'EventCallbackUrl' => '',
  'EventsFilter' => '',
  'FriendlyName' => '',
  'MultiTaskEnabled' => '',
  'PrioritizeQueueOrder' => '',
  'Template' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces');
$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/Workspaces' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template='

import http.client

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

payload = "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template="

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

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

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

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

import requests

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

payload = {
    "EventCallbackUrl": "",
    "EventsFilter": "",
    "FriendlyName": "",
    "MultiTaskEnabled": "",
    "PrioritizeQueueOrder": "",
    "Template": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

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

payload <- "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template="

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

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 = "EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template="

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

require 'faraday'

data = {
  :EventCallbackUrl => "",
  :EventsFilter => "",
  :FriendlyName => "",
  :MultiTaskEnabled => "",
  :PrioritizeQueueOrder => "",
  :Template => "",
}

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

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

    let payload = json!({
        "EventCallbackUrl": "",
        "EventsFilter": "",
        "FriendlyName": "",
        "MultiTaskEnabled": "",
        "PrioritizeQueueOrder": "",
        "Template": ""
    });

    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/Workspaces \
  content-type:application/x-www-form-urlencoded \
  EventCallbackUrl='' \
  EventsFilter='' \
  FriendlyName='' \
  MultiTaskEnabled='' \
  PrioritizeQueueOrder='' \
  Template=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'EventCallbackUrl=&EventsFilter=&FriendlyName=&MultiTaskEnabled=&PrioritizeQueueOrder=&Template=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces

import Foundation

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

let postData = NSMutableData(data: "EventCallbackUrl=".data(using: String.Encoding.utf8)!)
postData.append("&EventsFilter=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&MultiTaskEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&PrioritizeQueueOrder=".data(using: String.Encoding.utf8)!)
postData.append("&Template=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces")! 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/Workspaces/:WorkspaceSid/Activities/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Workspaces/:WorkspaceSid/Activities/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Tasks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskQueues/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/: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/Workspaces/:WorkspaceSid/Workers/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/: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/Workspaces/:WorkspaceSid/Workflows/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/: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/Workspaces/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/: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/Workspaces/:WorkspaceSid/Activities/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Activities/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Events/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/: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/Workspaces/:WorkspaceSid/Events/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Events/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/: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/Workspaces/:WorkspaceSid/Events/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events/: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/Workspaces/:WorkspaceSid/Tasks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskQueues/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/: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/Workspaces/:WorkspaceSid/TaskQueues/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/: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/Workspaces/:WorkspaceSid/TaskQueues/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/: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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics"

	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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics"))
    .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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")
  .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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics',
  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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics'
};

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics');

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics",
  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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics";

    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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/CumulativeStatistics")! 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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics"

	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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics"))
    .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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")
  .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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics',
  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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics'
};

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics');

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics",
  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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics";

    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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/RealTimeStatistics")! 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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics"

	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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics"))
    .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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")
  .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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics';
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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics',
  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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics'
};

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics');

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics';
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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics"]
                                                       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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics",
  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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")

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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics";

    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/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:TaskQueueSid/Statistics")! 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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/: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/Workspaces/:WorkspaceSid/Workers/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/: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/Workspaces/:WorkspaceSid/Workers/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid")

require "http/client"

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics"

	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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics"))
    .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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")
  .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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics';
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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics',
  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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics'
};

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics');

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics';
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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics"]
                                                       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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics",
  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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics";

    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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Statistics")! 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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations/: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/Workspaces/:WorkspaceSid/Workers/Statistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics"

	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/Workspaces/:WorkspaceSid/Workers/Statistics HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics"))
    .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/Workspaces/:WorkspaceSid/Workers/Statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics")
  .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/Workspaces/:WorkspaceSid/Workers/Statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics';
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/Workspaces/:WorkspaceSid/Workers/Statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/Statistics',
  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/Workspaces/:WorkspaceSid/Workers/Statistics'
};

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/Workspaces/:WorkspaceSid/Workers/Statistics');

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/Workspaces/:WorkspaceSid/Workers/Statistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics';
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/Workspaces/:WorkspaceSid/Workers/Statistics"]
                                                       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/Workspaces/:WorkspaceSid/Workers/Statistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics",
  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/Workspaces/:WorkspaceSid/Workers/Statistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/Statistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics")

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/Workspaces/:WorkspaceSid/Workers/Statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics";

    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/Workspaces/:WorkspaceSid/Workers/Statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/Statistics")! 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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics"

	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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics"))
    .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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")
  .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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics',
  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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics'
};

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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics');

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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics",
  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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")

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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics";

    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/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/CumulativeStatistics")! 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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics"

	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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics"))
    .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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")
  .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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics',
  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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics'
};

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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics');

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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics",
  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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")

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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics";

    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/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/RealTimeStatistics")! 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/Workspaces/:WorkspaceSid/Workflows/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/: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/Workspaces/:WorkspaceSid/Workflows/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/: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/Workspaces/:WorkspaceSid/Workflows/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/: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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics"

	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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics"))
    .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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")
  .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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics',
  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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics'
};

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics');

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics",
  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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics";

    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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/CumulativeStatistics")! 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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics"

	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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics"))
    .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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")
  .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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics',
  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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics'
};

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics');

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics",
  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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics";

    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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/RealTimeStatistics")! 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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics"

	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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics"))
    .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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")
  .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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics';
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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics',
  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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics'
};

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics');

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics';
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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics"]
                                                       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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics",
  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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")

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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics";

    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/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows/:WorkflowSid/Statistics")! 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/Workspaces/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:Sid")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/: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/Workspaces/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:Sid

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics"))
    .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/Workspaces/:WorkspaceSid/CumulativeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics")
  .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/Workspaces/:WorkspaceSid/CumulativeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/CumulativeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/CumulativeStatistics',
  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/Workspaces/:WorkspaceSid/CumulativeStatistics'
};

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/Workspaces/:WorkspaceSid/CumulativeStatistics');

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/Workspaces/:WorkspaceSid/CumulativeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics';
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/Workspaces/:WorkspaceSid/CumulativeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/CumulativeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics",
  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/Workspaces/:WorkspaceSid/CumulativeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/CumulativeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics")

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/Workspaces/:WorkspaceSid/CumulativeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/Workspaces/:WorkspaceSid/CumulativeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/CumulativeStatistics")! 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/Workspaces/:WorkspaceSid/RealTimeStatistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics"))
    .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/Workspaces/:WorkspaceSid/RealTimeStatistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics")
  .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/Workspaces/:WorkspaceSid/RealTimeStatistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/RealTimeStatistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/RealTimeStatistics',
  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/Workspaces/:WorkspaceSid/RealTimeStatistics'
};

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/Workspaces/:WorkspaceSid/RealTimeStatistics');

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/Workspaces/:WorkspaceSid/RealTimeStatistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics';
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/Workspaces/:WorkspaceSid/RealTimeStatistics"]
                                                       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/Workspaces/:WorkspaceSid/RealTimeStatistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics",
  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/Workspaces/:WorkspaceSid/RealTimeStatistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/RealTimeStatistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics")

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/Workspaces/:WorkspaceSid/RealTimeStatistics') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/Workspaces/:WorkspaceSid/RealTimeStatistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/RealTimeStatistics")! 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/Workspaces/:WorkspaceSid/Statistics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics"))
    .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/Workspaces/:WorkspaceSid/Statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics")
  .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/Workspaces/:WorkspaceSid/Statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics'
};

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics';
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/Workspaces/:WorkspaceSid/Statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Statistics',
  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/Workspaces/:WorkspaceSid/Statistics'
};

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/Workspaces/:WorkspaceSid/Statistics');

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/Workspaces/:WorkspaceSid/Statistics'
};

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

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

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics';
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/Workspaces/:WorkspaceSid/Statistics"]
                                                       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/Workspaces/:WorkspaceSid/Statistics" in

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

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics",
  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/Workspaces/:WorkspaceSid/Statistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Statistics")

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

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

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics")

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/Workspaces/:WorkspaceSid/Statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/Workspaces/:WorkspaceSid/Statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Statistics")! 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/Workspaces/:WorkspaceSid/Activities");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"

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

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"))
    .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/Workspaces/:WorkspaceSid/Activities")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")
  .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/Workspaces/:WorkspaceSid/Activities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities';
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/Workspaces/:WorkspaceSid/Activities',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Activities',
  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/Workspaces/:WorkspaceSid/Activities'
};

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/Workspaces/:WorkspaceSid/Activities');

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/Workspaces/:WorkspaceSid/Activities'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities';
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/Workspaces/:WorkspaceSid/Activities"]
                                                       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/Workspaces/:WorkspaceSid/Activities" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities",
  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/Workspaces/:WorkspaceSid/Activities');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Activities")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")

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/Workspaces/:WorkspaceSid/Activities') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities";

    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/Workspaces/:WorkspaceSid/Activities

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities")! 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/Workspaces/:WorkspaceSid/Events");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events"

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/Workspaces/:WorkspaceSid/Events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events"

	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/Workspaces/:WorkspaceSid/Events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events"))
    .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/Workspaces/:WorkspaceSid/Events")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events")
  .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/Workspaces/:WorkspaceSid/Events');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events';
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/Workspaces/:WorkspaceSid/Events',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Events',
  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/Workspaces/:WorkspaceSid/Events'
};

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/Workspaces/:WorkspaceSid/Events');

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/Workspaces/:WorkspaceSid/Events'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events';
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/Workspaces/:WorkspaceSid/Events"]
                                                       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/Workspaces/:WorkspaceSid/Events" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events",
  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/Workspaces/:WorkspaceSid/Events');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Events")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events")

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/Workspaces/:WorkspaceSid/Events') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events";

    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/Workspaces/:WorkspaceSid/Events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Events")! 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/Workspaces/:WorkspaceSid/Tasks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

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/Workspaces/:WorkspaceSid/Tasks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

	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/Workspaces/:WorkspaceSid/Tasks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"))
    .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/Workspaces/:WorkspaceSid/Tasks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .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/Workspaces/:WorkspaceSid/Tasks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks';
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/Workspaces/:WorkspaceSid/Tasks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks',
  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/Workspaces/:WorkspaceSid/Tasks'
};

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/Workspaces/:WorkspaceSid/Tasks');

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/Workspaces/:WorkspaceSid/Tasks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks';
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/Workspaces/:WorkspaceSid/Tasks"]
                                                       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/Workspaces/:WorkspaceSid/Tasks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks",
  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/Workspaces/:WorkspaceSid/Tasks');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")

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/Workspaces/:WorkspaceSid/Tasks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks";

    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/Workspaces/:WorkspaceSid/Tasks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks")! 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/Workspaces/:WorkspaceSid/TaskChannels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"

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/Workspaces/:WorkspaceSid/TaskChannels"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"

	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/Workspaces/:WorkspaceSid/TaskChannels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"))
    .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/Workspaces/:WorkspaceSid/TaskChannels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")
  .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/Workspaces/:WorkspaceSid/TaskChannels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels';
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/Workspaces/:WorkspaceSid/TaskChannels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels',
  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/Workspaces/:WorkspaceSid/TaskChannels'
};

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/Workspaces/:WorkspaceSid/TaskChannels');

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/Workspaces/:WorkspaceSid/TaskChannels'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels';
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/Workspaces/:WorkspaceSid/TaskChannels"]
                                                       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/Workspaces/:WorkspaceSid/TaskChannels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels",
  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/Workspaces/:WorkspaceSid/TaskChannels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")

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/Workspaces/:WorkspaceSid/TaskChannels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels";

    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/Workspaces/:WorkspaceSid/TaskChannels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels")! 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/Workspaces/:WorkspaceSid/TaskQueues");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

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/Workspaces/:WorkspaceSid/TaskQueues"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

	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/Workspaces/:WorkspaceSid/TaskQueues HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"))
    .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/Workspaces/:WorkspaceSid/TaskQueues")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .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/Workspaces/:WorkspaceSid/TaskQueues');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues';
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/Workspaces/:WorkspaceSid/TaskQueues',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues',
  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/Workspaces/:WorkspaceSid/TaskQueues'
};

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/Workspaces/:WorkspaceSid/TaskQueues');

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/Workspaces/:WorkspaceSid/TaskQueues'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues';
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/Workspaces/:WorkspaceSid/TaskQueues"]
                                                       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/Workspaces/:WorkspaceSid/TaskQueues" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues",
  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/Workspaces/:WorkspaceSid/TaskQueues');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")

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/Workspaces/:WorkspaceSid/TaskQueues') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues";

    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/Workspaces/:WorkspaceSid/TaskQueues

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues")! 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/Workspaces/:WorkspaceSid/TaskQueues/Statistics");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics"

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/Workspaces/:WorkspaceSid/TaskQueues/Statistics"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics"

	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/Workspaces/:WorkspaceSid/TaskQueues/Statistics HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics"))
    .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/Workspaces/:WorkspaceSid/TaskQueues/Statistics")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")
  .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/Workspaces/:WorkspaceSid/TaskQueues/Statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics';
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/Workspaces/:WorkspaceSid/TaskQueues/Statistics',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics',
  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/Workspaces/:WorkspaceSid/TaskQueues/Statistics'
};

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/Workspaces/:WorkspaceSid/TaskQueues/Statistics');

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/Workspaces/:WorkspaceSid/TaskQueues/Statistics'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics';
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/Workspaces/:WorkspaceSid/TaskQueues/Statistics"]
                                                       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/Workspaces/:WorkspaceSid/TaskQueues/Statistics" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics",
  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/Workspaces/:WorkspaceSid/TaskQueues/Statistics');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")

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/Workspaces/:WorkspaceSid/TaskQueues/Statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics";

    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/Workspaces/:WorkspaceSid/TaskQueues/Statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/Statistics")! 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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"

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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"

	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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"))
    .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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")
  .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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations';
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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations',
  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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations'
};

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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations');

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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations';
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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"]
                                                       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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations",
  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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")

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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations";

    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/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:TaskSid/Reservations")! 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/Workspaces/:WorkspaceSid/Workers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"

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/Workspaces/:WorkspaceSid/Workers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"

	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/Workspaces/:WorkspaceSid/Workers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"))
    .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/Workspaces/:WorkspaceSid/Workers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")
  .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/Workspaces/:WorkspaceSid/Workers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers';
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/Workspaces/:WorkspaceSid/Workers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workers',
  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/Workspaces/:WorkspaceSid/Workers'
};

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/Workspaces/:WorkspaceSid/Workers');

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/Workspaces/:WorkspaceSid/Workers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers';
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/Workspaces/:WorkspaceSid/Workers"]
                                                       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/Workspaces/:WorkspaceSid/Workers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers",
  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/Workspaces/:WorkspaceSid/Workers');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")

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/Workspaces/:WorkspaceSid/Workers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers";

    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/Workspaces/:WorkspaceSid/Workers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers")! 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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"

	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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"))
    .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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")
  .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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations';
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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations',
  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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations'
};

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations');

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations';
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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"]
                                                       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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations",
  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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")

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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations";

    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/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workers/:WorkerSid/Reservations")! 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/Workspaces/:WorkspaceSid/Workflows");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

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/Workspaces/:WorkspaceSid/Workflows"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

	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/Workspaces/:WorkspaceSid/Workflows HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"))
    .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/Workspaces/:WorkspaceSid/Workflows")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .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/Workspaces/:WorkspaceSid/Workflows');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows';
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/Workspaces/:WorkspaceSid/Workflows',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows',
  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/Workspaces/:WorkspaceSid/Workflows'
};

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/Workspaces/:WorkspaceSid/Workflows');

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/Workspaces/:WorkspaceSid/Workflows'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows';
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/Workspaces/:WorkspaceSid/Workflows"]
                                                       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/Workspaces/:WorkspaceSid/Workflows" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows",
  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/Workspaces/:WorkspaceSid/Workflows');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces/:WorkspaceSid/Workflows")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")

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/Workspaces/:WorkspaceSid/Workflows') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows";

    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/Workspaces/:WorkspaceSid/Workflows

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Workflows")! 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/Workspaces");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Workspaces")

require "http/client"

url = "{{baseUrl}}/v1/Workspaces"

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/Workspaces"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces"

	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/Workspaces HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Workspaces")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces"))
    .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/Workspaces")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Workspaces")
  .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/Workspaces');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Workspaces'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Workspaces';
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/Workspaces',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Workspaces',
  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/Workspaces'};

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/Workspaces');

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/Workspaces'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Workspaces';
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/Workspaces"]
                                                       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/Workspaces" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces",
  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/Workspaces');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Workspaces');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Workspaces' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Workspaces")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Workspaces")

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/Workspaces') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Workspaces";

    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/Workspaces

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Workspaces

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces")! 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/Workspaces/:WorkspaceSid/Activities/: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, "FriendlyName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid" {:form-params {:FriendlyName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid"
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/Workspaces/:WorkspaceSid/Activities/:Sid"),
    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/Workspaces/:WorkspaceSid/Activities/:Sid");
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/Workspaces/:WorkspaceSid/Activities/:Sid"

	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/Workspaces/:WorkspaceSid/Activities/:Sid 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/Workspaces/:WorkspaceSid/Activities/:Sid")
  .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/Workspaces/:WorkspaceSid/Activities/:Sid"))
    .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/Workspaces/:WorkspaceSid/Activities/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid")
  .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/Workspaces/:WorkspaceSid/Activities/:Sid');
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/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/:Sid';
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/Workspaces/:WorkspaceSid/Activities/:Sid',
  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/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/: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({FriendlyName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid',
  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/Workspaces/:WorkspaceSid/Activities/:Sid');

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/Workspaces/:WorkspaceSid/Activities/: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('FriendlyName', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/: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:[@"FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/:Sid" 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/Workspaces/:WorkspaceSid/Activities/: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 => "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/Workspaces/:WorkspaceSid/Activities/:Sid', [
  'form_params' => [
    'FriendlyName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid');
$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/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/:Sid' -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/Workspaces/:WorkspaceSid/Activities/:Sid' -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/Workspaces/:WorkspaceSid/Activities/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Activities/:Sid"

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/Workspaces/:WorkspaceSid/Activities/:Sid"

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/Workspaces/:WorkspaceSid/Activities/: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 = "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/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Activities/:Sid";

    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/Workspaces/:WorkspaceSid/Activities/:Sid \
  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/Workspaces/:WorkspaceSid/Activities/:Sid

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/Workspaces/:WorkspaceSid/Activities/: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/Workspaces/:WorkspaceSid/Tasks/: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, "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid" {:form-params {:AssignmentStatus ""
                                                                                                 :Attributes ""
                                                                                                 :Priority ""
                                                                                                 :Reason ""
                                                                                                 :TaskChannel ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel="

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/Workspaces/:WorkspaceSid/Tasks/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AssignmentStatus", "" },
        { "Attributes", "" },
        { "Priority", "" },
        { "Reason", "" },
        { "TaskChannel", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

	payload := strings.NewReader("AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=")

	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/Workspaces/:WorkspaceSid/Tasks/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 60

AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel="))
    .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, "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=")
  .asString();

const data = 'AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=';

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/Workspaces/:WorkspaceSid/Tasks/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AssignmentStatus', '');
encodedParams.set('Attributes', '');
encodedParams.set('Priority', '');
encodedParams.set('Reason', '');
encodedParams.set('TaskChannel', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AssignmentStatus: '',
    Attributes: '',
    Priority: '',
    Reason: '',
    TaskChannel: ''
  })
};

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/Workspaces/:WorkspaceSid/Tasks/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AssignmentStatus: '',
    Attributes: '',
    Priority: '',
    Reason: '',
    TaskChannel: ''
  }
};

$.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, "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/: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({
  AssignmentStatus: '',
  Attributes: '',
  Priority: '',
  Reason: '',
  TaskChannel: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AssignmentStatus: '',
    Attributes: '',
    Priority: '',
    Reason: '',
    TaskChannel: ''
  }
};

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/Workspaces/:WorkspaceSid/Tasks/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AssignmentStatus: '',
  Attributes: '',
  Priority: '',
  Reason: '',
  TaskChannel: ''
});

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('AssignmentStatus', '');
encodedParams.set('Attributes', '');
encodedParams.set('Priority', '');
encodedParams.set('Reason', '');
encodedParams.set('TaskChannel', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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('AssignmentStatus', '');
encodedParams.set('Attributes', '');
encodedParams.set('Priority', '');
encodedParams.set('Reason', '');
encodedParams.set('TaskChannel', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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:[@"AssignmentStatus=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Priority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Reason=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TaskChannel=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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 => "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=",
  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/Workspaces/:WorkspaceSid/Tasks/:Sid', [
  'form_params' => [
    'AssignmentStatus' => '',
    'Attributes' => '',
    'Priority' => '',
    'Reason' => '',
    'TaskChannel' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AssignmentStatus' => '',
  'Attributes' => '',
  'Priority' => '',
  'Reason' => '',
  'TaskChannel' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AssignmentStatus' => '',
  'Attributes' => '',
  'Priority' => '',
  'Reason' => '',
  'TaskChannel' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

payload = {
    "AssignmentStatus": "",
    "Attributes": "",
    "Priority": "",
    "Reason": "",
    "TaskChannel": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid"

payload <- "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel="

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/Workspaces/:WorkspaceSid/Tasks/: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 = "AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AssignmentStatus => "",
  :Attributes => "",
  :Priority => "",
  :Reason => "",
  :TaskChannel => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/Tasks/:Sid";

    let payload = json!({
        "AssignmentStatus": "",
        "Attributes": "",
        "Priority": "",
        "Reason": "",
        "TaskChannel": ""
    });

    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/Workspaces/:WorkspaceSid/Tasks/:Sid \
  content-type:application/x-www-form-urlencoded \
  AssignmentStatus='' \
  Attributes='' \
  Priority='' \
  Reason='' \
  TaskChannel=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AssignmentStatus=&Attributes=&Priority=&Reason=&TaskChannel=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AssignmentStatus=".data(using: String.Encoding.utf8)!)
postData.append("&Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Priority=".data(using: String.Encoding.utf8)!)
postData.append("&Reason=".data(using: String.Encoding.utf8)!)
postData.append("&TaskChannel=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/Tasks/: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/Workspaces/:WorkspaceSid/TaskChannels/: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, "ChannelOptimizedRouting=&FriendlyName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid" {:form-params {:ChannelOptimizedRouting ""
                                                                                                        :FriendlyName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ChannelOptimizedRouting", "" },
        { "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/Workspaces/:WorkspaceSid/TaskChannels/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ChannelOptimizedRouting=&FriendlyName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

	payload := strings.NewReader("ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 38

ChannelOptimizedRouting=&FriendlyName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ChannelOptimizedRouting=&FriendlyName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ChannelOptimizedRouting=&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, "ChannelOptimizedRouting=&FriendlyName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChannelOptimizedRouting=&FriendlyName=")
  .asString();

const data = 'ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ChannelOptimizedRouting', '');
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({ChannelOptimizedRouting: '', 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/Workspaces/:WorkspaceSid/TaskChannels/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ChannelOptimizedRouting: '',
    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, "ChannelOptimizedRouting=&FriendlyName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/: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({ChannelOptimizedRouting: '', FriendlyName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {ChannelOptimizedRouting: '', 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/Workspaces/:WorkspaceSid/TaskChannels/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ChannelOptimizedRouting: '',
  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('ChannelOptimizedRouting', '');
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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('ChannelOptimizedRouting', '');
encodedParams.set('FriendlyName', '');

const url = '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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:[@"ChannelOptimizedRouting=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ChannelOptimizedRouting=&FriendlyName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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 => "ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels/:Sid', [
  'form_params' => [
    'ChannelOptimizedRouting' => '',
    'FriendlyName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ChannelOptimizedRouting' => '',
  'FriendlyName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ChannelOptimizedRouting' => '',
  'FriendlyName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChannelOptimizedRouting=&FriendlyName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChannelOptimizedRouting=&FriendlyName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ChannelOptimizedRouting=&FriendlyName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

payload = {
    "ChannelOptimizedRouting": "",
    "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/Workspaces/:WorkspaceSid/TaskChannels/:Sid"

payload <- "ChannelOptimizedRouting=&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/Workspaces/:WorkspaceSid/TaskChannels/: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 = "ChannelOptimizedRouting=&FriendlyName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :ChannelOptimizedRouting => "",
  :FriendlyName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskChannels/:Sid";

    let payload = json!({
        "ChannelOptimizedRouting": "",
        "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/Workspaces/:WorkspaceSid/TaskChannels/:Sid \
  content-type:application/x-www-form-urlencoded \
  ChannelOptimizedRouting='' \
  FriendlyName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChannelOptimizedRouting=&FriendlyName=' \
  --output-document \
  - {{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ChannelOptimizedRouting=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskChannels/: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/Workspaces/:WorkspaceSid/TaskQueues/: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, "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid" {:form-params {:AssignmentActivitySid ""
                                                                                                      :FriendlyName ""
                                                                                                      :MaxReservedWorkers ""
                                                                                                      :ReservationActivitySid ""
                                                                                                      :TargetWorkers ""
                                                                                                      :TaskOrder ""}})

require "http/client"

url = "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="

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/Workspaces/:WorkspaceSid/TaskQueues/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AssignmentActivitySid", "" },
        { "FriendlyName", "" },
        { "MaxReservedWorkers", "" },
        { "ReservationActivitySid", "" },
        { "TargetWorkers", "" },
        { "TaskOrder", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"

	payload := strings.NewReader("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")

	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/Workspaces/:WorkspaceSid/TaskQueues/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 106

AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder="))
    .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, "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")
  .asString();

const data = 'AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=';

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/Workspaces/:WorkspaceSid/TaskQueues/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AssignmentActivitySid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MaxReservedWorkers', '');
encodedParams.set('ReservationActivitySid', '');
encodedParams.set('TargetWorkers', '');
encodedParams.set('TaskOrder', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/: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/Workspaces/:WorkspaceSid/TaskQueues/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AssignmentActivitySid: '',
    FriendlyName: '',
    MaxReservedWorkers: '',
    ReservationActivitySid: '',
    TargetWorkers: '',
    TaskOrder: ''
  })
};

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/Workspaces/:WorkspaceSid/TaskQueues/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AssignmentActivitySid: '',
    FriendlyName: '',
    MaxReservedWorkers: '',
    ReservationActivitySid: '',
    TargetWorkers: '',
    TaskOrder: ''
  }
};

$.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, "AssignmentActivitySid=&FriendlyName=&MaxReservedWorkers=&ReservationActivitySid=&TargetWorkers=&TaskOrder=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Workspaces/:WorkspaceSid/TaskQueues/: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/Workspaces/:WorkspaceSid/TaskQueues/: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({
  AssignmentActivitySid: '',
  FriendlyName: '',
  MaxReservedWorkers: '',
  ReservationActivitySid: '',
  TargetWorkers: '',
  TaskOrder: ''
}));
req.end();