Twilio - Flex

POST CreateChannel

{{baseUrl}}/v1/Channels

BODY formUrlEncoded

ChatFriendlyName

ChatUniqueName

ChatUserFriendlyName

FlexFlowSid

Identity

LongLived

PreEngagementData

Target

TaskAttributes

TaskSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Channels" {:form-params {:ChatFriendlyName ""
                                                                      :ChatUniqueName ""
                                                                      :ChatUserFriendlyName ""
                                                                      :FlexFlowSid ""
                                                                      :Identity ""
                                                                      :LongLived ""
                                                                      :PreEngagementData ""
                                                                      :Target ""
                                                                      :TaskAttributes ""
                                                                      :TaskSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Channels"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid="

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/Channels"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ChatFriendlyName", "" },
        { "ChatUniqueName", "" },
        { "ChatUserFriendlyName", "" },
        { "FlexFlowSid", "" },
        { "Identity", "" },
        { "LongLived", "" },
        { "PreEngagementData", "" },
        { "Target", "" },
        { "TaskAttributes", "" },
        { "TaskSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Channels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=")

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

ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Channels")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Channels"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid="))
    .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, "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Channels")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Channels")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=")
  .asString();

const data = 'ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ChatFriendlyName', '');
encodedParams.set('ChatUniqueName', '');
encodedParams.set('ChatUserFriendlyName', '');
encodedParams.set('FlexFlowSid', '');
encodedParams.set('Identity', '');
encodedParams.set('LongLived', '');
encodedParams.set('PreEngagementData', '');
encodedParams.set('Target', '');
encodedParams.set('TaskAttributes', '');
encodedParams.set('TaskSid', '');

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

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

const url = '{{baseUrl}}/v1/Channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ChatFriendlyName: '',
    ChatUniqueName: '',
    ChatUserFriendlyName: '',
    FlexFlowSid: '',
    Identity: '',
    LongLived: '',
    PreEngagementData: '',
    Target: '',
    TaskAttributes: '',
    TaskSid: ''
  })
};

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/Channels',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ChatFriendlyName: '',
    ChatUniqueName: '',
    ChatUserFriendlyName: '',
    FlexFlowSid: '',
    Identity: '',
    LongLived: '',
    PreEngagementData: '',
    Target: '',
    TaskAttributes: '',
    TaskSid: ''
  }
};

$.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, "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Channels")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

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

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

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

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

req.write(qs.stringify({
  ChatFriendlyName: '',
  ChatUniqueName: '',
  ChatUserFriendlyName: '',
  FlexFlowSid: '',
  Identity: '',
  LongLived: '',
  PreEngagementData: '',
  Target: '',
  TaskAttributes: '',
  TaskSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Channels',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ChatFriendlyName: '',
    ChatUniqueName: '',
    ChatUserFriendlyName: '',
    FlexFlowSid: '',
    Identity: '',
    LongLived: '',
    PreEngagementData: '',
    Target: '',
    TaskAttributes: '',
    TaskSid: ''
  }
};

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

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

req.form({
  ChatFriendlyName: '',
  ChatUniqueName: '',
  ChatUserFriendlyName: '',
  FlexFlowSid: '',
  Identity: '',
  LongLived: '',
  PreEngagementData: '',
  Target: '',
  TaskAttributes: '',
  TaskSid: ''
});

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('ChatFriendlyName', '');
encodedParams.set('ChatUniqueName', '');
encodedParams.set('ChatUserFriendlyName', '');
encodedParams.set('FlexFlowSid', '');
encodedParams.set('Identity', '');
encodedParams.set('LongLived', '');
encodedParams.set('PreEngagementData', '');
encodedParams.set('Target', '');
encodedParams.set('TaskAttributes', '');
encodedParams.set('TaskSid', '');

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('ChatFriendlyName', '');
encodedParams.set('ChatUniqueName', '');
encodedParams.set('ChatUserFriendlyName', '');
encodedParams.set('FlexFlowSid', '');
encodedParams.set('Identity', '');
encodedParams.set('LongLived', '');
encodedParams.set('PreEngagementData', '');
encodedParams.set('Target', '');
encodedParams.set('TaskAttributes', '');
encodedParams.set('TaskSid', '');

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

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"ChatFriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatUniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatUserFriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FlexFlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LongLived=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PreEngagementData=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Target=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TaskAttributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TaskSid=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Channels" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=" in

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

 "{{baseUrl}}/v1/Channels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=",
  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/Channels', [
  'form_params' => [
    'ChatFriendlyName' => '',
    'ChatUniqueName' => '',
    'ChatUserFriendlyName' => '',
    'FlexFlowSid' => '',
    'Identity' => '',
    'LongLived' => '',
    'PreEngagementData' => '',
    'Target' => '',
    'TaskAttributes' => '',
    'TaskSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ChatFriendlyName' => '',
  'ChatUniqueName' => '',
  'ChatUserFriendlyName' => '',
  'FlexFlowSid' => '',
  'Identity' => '',
  'LongLived' => '',
  'PreEngagementData' => '',
  'Target' => '',
  'TaskAttributes' => '',
  'TaskSid' => ''
]);

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

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

append(new http\QueryString([
  'ChatFriendlyName' => '',
  'ChatUniqueName' => '',
  'ChatUserFriendlyName' => '',
  'FlexFlowSid' => '',
  'Identity' => '',
  'LongLived' => '',
  'PreEngagementData' => '',
  'Target' => '',
  'TaskAttributes' => '',
  'TaskSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Channels');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Channels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Channels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid='

import http.client

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

payload = "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid="

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

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

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

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

import requests

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

payload = {
    "ChatFriendlyName": "",
    "ChatUniqueName": "",
    "ChatUserFriendlyName": "",
    "FlexFlowSid": "",
    "Identity": "",
    "LongLived": "",
    "PreEngagementData": "",
    "Target": "",
    "TaskAttributes": "",
    "TaskSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

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

payload <- "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid="

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid="

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

require 'faraday'

data = {
  :ChatFriendlyName => "",
  :ChatUniqueName => "",
  :ChatUserFriendlyName => "",
  :FlexFlowSid => "",
  :Identity => "",
  :LongLived => "",
  :PreEngagementData => "",
  :Target => "",
  :TaskAttributes => "",
  :TaskSid => "",
}

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

response = conn.post('/baseUrl/v1/Channels') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ChatFriendlyName": "",
        "ChatUniqueName": "",
        "ChatUserFriendlyName": "",
        "FlexFlowSid": "",
        "Identity": "",
        "LongLived": "",
        "PreEngagementData": "",
        "Target": "",
        "TaskAttributes": "",
        "TaskSid": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Channels \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ChatFriendlyName= \
  --data ChatUniqueName= \
  --data ChatUserFriendlyName= \
  --data FlexFlowSid= \
  --data Identity= \
  --data LongLived= \
  --data PreEngagementData= \
  --data Target= \
  --data TaskAttributes= \
  --data TaskSid=

http --form POST {{baseUrl}}/v1/Channels \
  content-type:application/x-www-form-urlencoded \
  ChatFriendlyName='' \
  ChatUniqueName='' \
  ChatUserFriendlyName='' \
  FlexFlowSid='' \
  Identity='' \
  LongLived='' \
  PreEngagementData='' \
  Target='' \
  TaskAttributes='' \
  TaskSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChatFriendlyName=&ChatUniqueName=&ChatUserFriendlyName=&FlexFlowSid=&Identity=&LongLived=&PreEngagementData=&Target=&TaskAttributes=&TaskSid=' \
  --output-document \
  - {{baseUrl}}/v1/Channels

import Foundation

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

let postData = NSMutableData(data: "ChatFriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&ChatUniqueName=".data(using: String.Encoding.utf8)!)
postData.append("&ChatUserFriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&FlexFlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&LongLived=".data(using: String.Encoding.utf8)!)
postData.append("&PreEngagementData=".data(using: String.Encoding.utf8)!)
postData.append("&Target=".data(using: String.Encoding.utf8)!)
postData.append("&TaskAttributes=".data(using: String.Encoding.utf8)!)
postData.append("&TaskSid=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST CreateFlexFlow

{{baseUrl}}/v1/FlexFlows

BODY formUrlEncoded

ChannelType

ChatServiceSid

ContactIdentity

Enabled

FriendlyName

Integration.Channel

Integration.CreationOnMessage

Integration.FlowSid

Integration.Priority

Integration.RetryCount

Integration.Timeout

Integration.Url

Integration.WorkflowSid

Integration.WorkspaceSid

IntegrationType

JanitorEnabled

LongLived

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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, "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/FlexFlows" {:form-params {:ChannelType ""
                                                                       :ChatServiceSid ""
                                                                       :ContactIdentity ""
                                                                       :Enabled ""
                                                                       :FriendlyName ""
                                                                       :Integration.Channel ""
                                                                       :Integration.CreationOnMessage ""
                                                                       :Integration.FlowSid ""
                                                                       :Integration.Priority ""
                                                                       :Integration.RetryCount ""
                                                                       :Integration.Timeout ""
                                                                       :Integration.Url ""
                                                                       :Integration.WorkflowSid ""
                                                                       :Integration.WorkspaceSid ""
                                                                       :IntegrationType ""
                                                                       :JanitorEnabled ""
                                                                       :LongLived ""}})

require "http/client"

url = "{{baseUrl}}/v1/FlexFlows"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

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/FlexFlows"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ChannelType", "" },
        { "ChatServiceSid", "" },
        { "ContactIdentity", "" },
        { "Enabled", "" },
        { "FriendlyName", "" },
        { "Integration.Channel", "" },
        { "Integration.CreationOnMessage", "" },
        { "Integration.FlowSid", "" },
        { "Integration.Priority", "" },
        { "Integration.RetryCount", "" },
        { "Integration.Timeout", "" },
        { "Integration.Url", "" },
        { "Integration.WorkflowSid", "" },
        { "Integration.WorkspaceSid", "" },
        { "IntegrationType", "" },
        { "JanitorEnabled", "" },
        { "LongLived", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/FlexFlows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")

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

ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/FlexFlows")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/FlexFlows"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="))
    .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, "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/FlexFlows")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/FlexFlows")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")
  .asString();

const data = 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ChannelType', '');
encodedParams.set('ChatServiceSid', '');
encodedParams.set('ContactIdentity', '');
encodedParams.set('Enabled', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Integration.Channel', '');
encodedParams.set('Integration.CreationOnMessage', '');
encodedParams.set('Integration.FlowSid', '');
encodedParams.set('Integration.Priority', '');
encodedParams.set('Integration.RetryCount', '');
encodedParams.set('Integration.Timeout', '');
encodedParams.set('Integration.Url', '');
encodedParams.set('Integration.WorkflowSid', '');
encodedParams.set('Integration.WorkspaceSid', '');
encodedParams.set('IntegrationType', '');
encodedParams.set('JanitorEnabled', '');
encodedParams.set('LongLived', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/FlexFlows',
  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/FlexFlows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ChannelType: '',
    ChatServiceSid: '',
    ContactIdentity: '',
    Enabled: '',
    FriendlyName: '',
    'Integration.Channel': '',
    'Integration.CreationOnMessage': '',
    'Integration.FlowSid': '',
    'Integration.Priority': '',
    'Integration.RetryCount': '',
    'Integration.Timeout': '',
    'Integration.Url': '',
    'Integration.WorkflowSid': '',
    'Integration.WorkspaceSid': '',
    IntegrationType: '',
    JanitorEnabled: '',
    LongLived: ''
  })
};

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/FlexFlows',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ChannelType: '',
    ChatServiceSid: '',
    ContactIdentity: '',
    Enabled: '',
    FriendlyName: '',
    'Integration.Channel': '',
    'Integration.CreationOnMessage': '',
    'Integration.FlowSid': '',
    'Integration.Priority': '',
    'Integration.RetryCount': '',
    'Integration.Timeout': '',
    'Integration.Url': '',
    'Integration.WorkflowSid': '',
    'Integration.WorkspaceSid': '',
    IntegrationType: '',
    JanitorEnabled: '',
    LongLived: ''
  }
};

$.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, "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/FlexFlows")
  .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/FlexFlows',
  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({
  ChannelType: '',
  ChatServiceSid: '',
  ContactIdentity: '',
  Enabled: '',
  FriendlyName: '',
  'Integration.Channel': '',
  'Integration.CreationOnMessage': '',
  'Integration.FlowSid': '',
  'Integration.Priority': '',
  'Integration.RetryCount': '',
  'Integration.Timeout': '',
  'Integration.Url': '',
  'Integration.WorkflowSid': '',
  'Integration.WorkspaceSid': '',
  IntegrationType: '',
  JanitorEnabled: '',
  LongLived: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/FlexFlows',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ChannelType: '',
    ChatServiceSid: '',
    ContactIdentity: '',
    Enabled: '',
    FriendlyName: '',
    'Integration.Channel': '',
    'Integration.CreationOnMessage': '',
    'Integration.FlowSid': '',
    'Integration.Priority': '',
    'Integration.RetryCount': '',
    'Integration.Timeout': '',
    'Integration.Url': '',
    'Integration.WorkflowSid': '',
    'Integration.WorkspaceSid': '',
    IntegrationType: '',
    JanitorEnabled: '',
    LongLived: ''
  }
};

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

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

req.form({
  ChannelType: '',
  ChatServiceSid: '',
  ContactIdentity: '',
  Enabled: '',
  FriendlyName: '',
  'Integration.Channel': '',
  'Integration.CreationOnMessage': '',
  'Integration.FlowSid': '',
  'Integration.Priority': '',
  'Integration.RetryCount': '',
  'Integration.Timeout': '',
  'Integration.Url': '',
  'Integration.WorkflowSid': '',
  'Integration.WorkspaceSid': '',
  IntegrationType: '',
  JanitorEnabled: '',
  LongLived: ''
});

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('ChannelType', '');
encodedParams.set('ChatServiceSid', '');
encodedParams.set('ContactIdentity', '');
encodedParams.set('Enabled', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Integration.Channel', '');
encodedParams.set('Integration.CreationOnMessage', '');
encodedParams.set('Integration.FlowSid', '');
encodedParams.set('Integration.Priority', '');
encodedParams.set('Integration.RetryCount', '');
encodedParams.set('Integration.Timeout', '');
encodedParams.set('Integration.Url', '');
encodedParams.set('Integration.WorkflowSid', '');
encodedParams.set('Integration.WorkspaceSid', '');
encodedParams.set('IntegrationType', '');
encodedParams.set('JanitorEnabled', '');
encodedParams.set('LongLived', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/FlexFlows',
  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('ChannelType', '');
encodedParams.set('ChatServiceSid', '');
encodedParams.set('ContactIdentity', '');
encodedParams.set('Enabled', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Integration.Channel', '');
encodedParams.set('Integration.CreationOnMessage', '');
encodedParams.set('Integration.FlowSid', '');
encodedParams.set('Integration.Priority', '');
encodedParams.set('Integration.RetryCount', '');
encodedParams.set('Integration.Timeout', '');
encodedParams.set('Integration.Url', '');
encodedParams.set('Integration.WorkflowSid', '');
encodedParams.set('Integration.WorkspaceSid', '');
encodedParams.set('IntegrationType', '');
encodedParams.set('JanitorEnabled', '');
encodedParams.set('LongLived', '');

const url = '{{baseUrl}}/v1/FlexFlows';
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:[@"ChannelType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ContactIdentity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Channel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.CreationOnMessage=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.FlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Priority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.RetryCount=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Timeout=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.WorkflowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.WorkspaceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&IntegrationType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&JanitorEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LongLived=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/FlexFlows"]
                                                       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/FlexFlows" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=" in

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

 "{{baseUrl}}/v1/FlexFlows",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=",
  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/FlexFlows', [
  'form_params' => [
    'ChannelType' => '',
    'ChatServiceSid' => '',
    'ContactIdentity' => '',
    'Enabled' => '',
    'FriendlyName' => '',
    'Integration.Channel' => '',
    'Integration.CreationOnMessage' => '',
    'Integration.FlowSid' => '',
    'Integration.Priority' => '',
    'Integration.RetryCount' => '',
    'Integration.Timeout' => '',
    'Integration.Url' => '',
    'Integration.WorkflowSid' => '',
    'Integration.WorkspaceSid' => '',
    'IntegrationType' => '',
    'JanitorEnabled' => '',
    'LongLived' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ChannelType' => '',
  'ChatServiceSid' => '',
  'ContactIdentity' => '',
  'Enabled' => '',
  'FriendlyName' => '',
  'Integration.Channel' => '',
  'Integration.CreationOnMessage' => '',
  'Integration.FlowSid' => '',
  'Integration.Priority' => '',
  'Integration.RetryCount' => '',
  'Integration.Timeout' => '',
  'Integration.Url' => '',
  'Integration.WorkflowSid' => '',
  'Integration.WorkspaceSid' => '',
  'IntegrationType' => '',
  'JanitorEnabled' => '',
  'LongLived' => ''
]);

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

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

append(new http\QueryString([
  'ChannelType' => '',
  'ChatServiceSid' => '',
  'ContactIdentity' => '',
  'Enabled' => '',
  'FriendlyName' => '',
  'Integration.Channel' => '',
  'Integration.CreationOnMessage' => '',
  'Integration.FlowSid' => '',
  'Integration.Priority' => '',
  'Integration.RetryCount' => '',
  'Integration.Timeout' => '',
  'Integration.Url' => '',
  'Integration.WorkflowSid' => '',
  'Integration.WorkspaceSid' => '',
  'IntegrationType' => '',
  'JanitorEnabled' => '',
  'LongLived' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/FlexFlows');
$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/FlexFlows' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/FlexFlows' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived='

import http.client

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

payload = "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

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

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

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

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

import requests

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

payload = {
    "ChannelType": "",
    "ChatServiceSid": "",
    "ContactIdentity": "",
    "Enabled": "",
    "FriendlyName": "",
    "Integration.Channel": "",
    "Integration.CreationOnMessage": "",
    "Integration.FlowSid": "",
    "Integration.Priority": "",
    "Integration.RetryCount": "",
    "Integration.Timeout": "",
    "Integration.Url": "",
    "Integration.WorkflowSid": "",
    "Integration.WorkspaceSid": "",
    "IntegrationType": "",
    "JanitorEnabled": "",
    "LongLived": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

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

payload <- "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

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

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 = "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

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

require 'faraday'

data = {
  :ChannelType => "",
  :ChatServiceSid => "",
  :ContactIdentity => "",
  :Enabled => "",
  :FriendlyName => "",
  :Integration.Channel => "",
  :Integration.CreationOnMessage => "",
  :Integration.FlowSid => "",
  :Integration.Priority => "",
  :Integration.RetryCount => "",
  :Integration.Timeout => "",
  :Integration.Url => "",
  :Integration.WorkflowSid => "",
  :Integration.WorkspaceSid => "",
  :IntegrationType => "",
  :JanitorEnabled => "",
  :LongLived => "",
}

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

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

    let payload = json!({
        "ChannelType": "",
        "ChatServiceSid": "",
        "ContactIdentity": "",
        "Enabled": "",
        "FriendlyName": "",
        "Integration.Channel": "",
        "Integration.CreationOnMessage": "",
        "Integration.FlowSid": "",
        "Integration.Priority": "",
        "Integration.RetryCount": "",
        "Integration.Timeout": "",
        "Integration.Url": "",
        "Integration.WorkflowSid": "",
        "Integration.WorkspaceSid": "",
        "IntegrationType": "",
        "JanitorEnabled": "",
        "LongLived": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/FlexFlows \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ChannelType= \
  --data ChatServiceSid= \
  --data ContactIdentity= \
  --data Enabled= \
  --data FriendlyName= \
  --data Integration.Channel= \
  --data Integration.CreationOnMessage= \
  --data Integration.FlowSid= \
  --data Integration.Priority= \
  --data Integration.RetryCount= \
  --data Integration.Timeout= \
  --data Integration.Url= \
  --data Integration.WorkflowSid= \
  --data Integration.WorkspaceSid= \
  --data IntegrationType= \
  --data JanitorEnabled= \
  --data LongLived=

http --form POST {{baseUrl}}/v1/FlexFlows \
  content-type:application/x-www-form-urlencoded \
  ChannelType='' \
  ChatServiceSid='' \
  ContactIdentity='' \
  Enabled='' \
  FriendlyName='' \
  Integration.Channel='' \
  Integration.CreationOnMessage='' \
  Integration.FlowSid='' \
  Integration.Priority='' \
  Integration.RetryCount='' \
  Integration.Timeout='' \
  Integration.Url='' \
  Integration.WorkflowSid='' \
  Integration.WorkspaceSid='' \
  IntegrationType='' \
  JanitorEnabled='' \
  LongLived=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=' \
  --output-document \
  - {{baseUrl}}/v1/FlexFlows

import Foundation

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

let postData = NSMutableData(data: "ChannelType=".data(using: String.Encoding.utf8)!)
postData.append("&ChatServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&ContactIdentity=".data(using: String.Encoding.utf8)!)
postData.append("&Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Channel=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.CreationOnMessage=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.FlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Priority=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.RetryCount=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Timeout=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.WorkflowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.WorkspaceSid=".data(using: String.Encoding.utf8)!)
postData.append("&IntegrationType=".data(using: String.Encoding.utf8)!)
postData.append("&JanitorEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&LongLived=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST CreateInsightsAssessments

{{baseUrl}}/v1/Insights/QM/Assessments

BODY formUrlEncoded

AgentId

AnswerId

AnswerText

CategoryId

CategoryName

MetricId

MetricName

Offset

QuestionnaireId

SegmentId

UserEmail

UserName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Assessments");

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, "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Insights/QM/Assessments" {:form-params {:AgentId ""
                                                                                     :AnswerId ""
                                                                                     :AnswerText ""
                                                                                     :CategoryId ""
                                                                                     :CategoryName ""
                                                                                     :MetricId ""
                                                                                     :MetricName ""
                                                                                     :Offset ""
                                                                                     :QuestionnaireId ""
                                                                                     :SegmentId ""
                                                                                     :UserEmail ""
                                                                                     :UserName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Assessments"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName="

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/Insights/QM/Assessments"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AgentId", "" },
        { "AnswerId", "" },
        { "AnswerText", "" },
        { "CategoryId", "" },
        { "CategoryName", "" },
        { "MetricId", "" },
        { "MetricName", "" },
        { "Offset", "" },
        { "QuestionnaireId", "" },
        { "SegmentId", "" },
        { "UserEmail", "" },
        { "UserName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Assessments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Assessments"

	payload := strings.NewReader("AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=")

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

AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Assessments")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Assessments"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName="))
    .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, "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Assessments")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=")
  .asString();

const data = 'AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AgentId', '');
encodedParams.set('AnswerId', '');
encodedParams.set('AnswerText', '');
encodedParams.set('CategoryId', '');
encodedParams.set('CategoryName', '');
encodedParams.set('MetricId', '');
encodedParams.set('MetricName', '');
encodedParams.set('Offset', '');
encodedParams.set('QuestionnaireId', '');
encodedParams.set('SegmentId', '');
encodedParams.set('UserEmail', '');
encodedParams.set('UserName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments',
  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/Insights/QM/Assessments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AgentId: '',
    AnswerId: '',
    AnswerText: '',
    CategoryId: '',
    CategoryName: '',
    MetricId: '',
    MetricName: '',
    Offset: '',
    QuestionnaireId: '',
    SegmentId: '',
    UserEmail: '',
    UserName: ''
  })
};

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/Insights/QM/Assessments',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AgentId: '',
    AnswerId: '',
    AnswerText: '',
    CategoryId: '',
    CategoryName: '',
    MetricId: '',
    MetricName: '',
    Offset: '',
    QuestionnaireId: '',
    SegmentId: '',
    UserEmail: '',
    UserName: ''
  }
};

$.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, "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments")
  .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/Insights/QM/Assessments',
  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({
  AgentId: '',
  AnswerId: '',
  AnswerText: '',
  CategoryId: '',
  CategoryName: '',
  MetricId: '',
  MetricName: '',
  Offset: '',
  QuestionnaireId: '',
  SegmentId: '',
  UserEmail: '',
  UserName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AgentId: '',
    AnswerId: '',
    AnswerText: '',
    CategoryId: '',
    CategoryName: '',
    MetricId: '',
    MetricName: '',
    Offset: '',
    QuestionnaireId: '',
    SegmentId: '',
    UserEmail: '',
    UserName: ''
  }
};

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/Insights/QM/Assessments');

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

req.form({
  AgentId: '',
  AnswerId: '',
  AnswerText: '',
  CategoryId: '',
  CategoryName: '',
  MetricId: '',
  MetricName: '',
  Offset: '',
  QuestionnaireId: '',
  SegmentId: '',
  UserEmail: '',
  UserName: ''
});

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('AgentId', '');
encodedParams.set('AnswerId', '');
encodedParams.set('AnswerText', '');
encodedParams.set('CategoryId', '');
encodedParams.set('CategoryName', '');
encodedParams.set('MetricId', '');
encodedParams.set('MetricName', '');
encodedParams.set('Offset', '');
encodedParams.set('QuestionnaireId', '');
encodedParams.set('SegmentId', '');
encodedParams.set('UserEmail', '');
encodedParams.set('UserName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments',
  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('AgentId', '');
encodedParams.set('AnswerId', '');
encodedParams.set('AnswerText', '');
encodedParams.set('CategoryId', '');
encodedParams.set('CategoryName', '');
encodedParams.set('MetricId', '');
encodedParams.set('MetricName', '');
encodedParams.set('Offset', '');
encodedParams.set('QuestionnaireId', '');
encodedParams.set('SegmentId', '');
encodedParams.set('UserEmail', '');
encodedParams.set('UserName', '');

const url = '{{baseUrl}}/v1/Insights/QM/Assessments';
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:[@"AgentId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AnswerId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AnswerText=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CategoryId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CategoryName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MetricId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MetricName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Offset=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&QuestionnaireId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SegmentId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UserEmail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UserName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Assessments"]
                                                       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/Insights/QM/Assessments" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=" in

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

 "{{baseUrl}}/v1/Insights/QM/Assessments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=",
  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/Insights/QM/Assessments', [
  'form_params' => [
    'AgentId' => '',
    'AnswerId' => '',
    'AnswerText' => '',
    'CategoryId' => '',
    'CategoryName' => '',
    'MetricId' => '',
    'MetricName' => '',
    'Offset' => '',
    'QuestionnaireId' => '',
    'SegmentId' => '',
    'UserEmail' => '',
    'UserName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AgentId' => '',
  'AnswerId' => '',
  'AnswerText' => '',
  'CategoryId' => '',
  'CategoryName' => '',
  'MetricId' => '',
  'MetricName' => '',
  'Offset' => '',
  'QuestionnaireId' => '',
  'SegmentId' => '',
  'UserEmail' => '',
  'UserName' => ''
]);

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

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

append(new http\QueryString([
  'AgentId' => '',
  'AnswerId' => '',
  'AnswerText' => '',
  'CategoryId' => '',
  'CategoryName' => '',
  'MetricId' => '',
  'MetricName' => '',
  'Offset' => '',
  'QuestionnaireId' => '',
  'SegmentId' => '',
  'UserEmail' => '',
  'UserName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Assessments');
$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/Insights/QM/Assessments' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Assessments' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName='

import http.client

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

payload = "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName="

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

conn.request("POST", "/baseUrl/v1/Insights/QM/Assessments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Assessments"

payload = {
    "AgentId": "",
    "AnswerId": "",
    "AnswerText": "",
    "CategoryId": "",
    "CategoryName": "",
    "MetricId": "",
    "MetricName": "",
    "Offset": "",
    "QuestionnaireId": "",
    "SegmentId": "",
    "UserEmail": "",
    "UserName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Assessments"

payload <- "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName="

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/Insights/QM/Assessments")

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 = "AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName="

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

require 'faraday'

data = {
  :AgentId => "",
  :AnswerId => "",
  :AnswerText => "",
  :CategoryId => "",
  :CategoryName => "",
  :MetricId => "",
  :MetricName => "",
  :Offset => "",
  :QuestionnaireId => "",
  :SegmentId => "",
  :UserEmail => "",
  :UserName => "",
}

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

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

    let payload = json!({
        "AgentId": "",
        "AnswerId": "",
        "AnswerText": "",
        "CategoryId": "",
        "CategoryName": "",
        "MetricId": "",
        "MetricName": "",
        "Offset": "",
        "QuestionnaireId": "",
        "SegmentId": "",
        "UserEmail": "",
        "UserName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Assessments \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AgentId= \
  --data AnswerId= \
  --data AnswerText= \
  --data CategoryId= \
  --data CategoryName= \
  --data MetricId= \
  --data MetricName= \
  --data Offset= \
  --data QuestionnaireId= \
  --data SegmentId= \
  --data UserEmail= \
  --data UserName=

http --form POST {{baseUrl}}/v1/Insights/QM/Assessments \
  content-type:application/x-www-form-urlencoded \
  AgentId='' \
  AnswerId='' \
  AnswerText='' \
  CategoryId='' \
  CategoryName='' \
  MetricId='' \
  MetricName='' \
  Offset='' \
  QuestionnaireId='' \
  SegmentId='' \
  UserEmail='' \
  UserName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AgentId=&AnswerId=&AnswerText=&CategoryId=&CategoryName=&MetricId=&MetricName=&Offset=&QuestionnaireId=&SegmentId=&UserEmail=&UserName=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Assessments

import Foundation

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

let postData = NSMutableData(data: "AgentId=".data(using: String.Encoding.utf8)!)
postData.append("&AnswerId=".data(using: String.Encoding.utf8)!)
postData.append("&AnswerText=".data(using: String.Encoding.utf8)!)
postData.append("&CategoryId=".data(using: String.Encoding.utf8)!)
postData.append("&CategoryName=".data(using: String.Encoding.utf8)!)
postData.append("&MetricId=".data(using: String.Encoding.utf8)!)
postData.append("&MetricName=".data(using: String.Encoding.utf8)!)
postData.append("&Offset=".data(using: String.Encoding.utf8)!)
postData.append("&QuestionnaireId=".data(using: String.Encoding.utf8)!)
postData.append("&SegmentId=".data(using: String.Encoding.utf8)!)
postData.append("&UserEmail=".data(using: String.Encoding.utf8)!)
postData.append("&UserName=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST CreateInsightsAssessmentsComment

{{baseUrl}}/v1/Insights/QM/Assessments/Comments

BODY formUrlEncoded

AgentId

CategoryId

CategoryName

Comment

Offset

SegmentId

UserEmail

UserName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Assessments/Comments");

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, "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Insights/QM/Assessments/Comments" {:form-params {:AgentId ""
                                                                                              :CategoryId ""
                                                                                              :CategoryName ""
                                                                                              :Comment ""
                                                                                              :Offset ""
                                                                                              :SegmentId ""
                                                                                              :UserEmail ""
                                                                                              :UserName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName="

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/Insights/QM/Assessments/Comments"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AgentId", "" },
        { "CategoryId", "" },
        { "CategoryName", "" },
        { "Comment", "" },
        { "Offset", "" },
        { "SegmentId", "" },
        { "UserEmail", "" },
        { "UserName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Assessments/Comments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

	payload := strings.NewReader("AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=")

	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/Insights/QM/Assessments/Comments HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 83

AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Assessments/Comments"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName="))
    .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, "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=")
  .asString();

const data = 'AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AgentId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('CategoryName', '');
encodedParams.set('Comment', '');
encodedParams.set('Offset', '');
encodedParams.set('SegmentId', '');
encodedParams.set('UserEmail', '');
encodedParams.set('UserName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/Comments',
  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/Insights/QM/Assessments/Comments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    AgentId: '',
    CategoryId: '',
    CategoryName: '',
    Comment: '',
    Offset: '',
    SegmentId: '',
    UserEmail: '',
    UserName: ''
  })
};

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/Insights/QM/Assessments/Comments',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AgentId: '',
    CategoryId: '',
    CategoryName: '',
    Comment: '',
    Offset: '',
    SegmentId: '',
    UserEmail: '',
    UserName: ''
  }
};

$.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, "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .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/Insights/QM/Assessments/Comments',
  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({
  AgentId: '',
  CategoryId: '',
  CategoryName: '',
  Comment: '',
  Offset: '',
  SegmentId: '',
  UserEmail: '',
  UserName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/Comments',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    AgentId: '',
    CategoryId: '',
    CategoryName: '',
    Comment: '',
    Offset: '',
    SegmentId: '',
    UserEmail: '',
    UserName: ''
  }
};

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/Insights/QM/Assessments/Comments');

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

req.form({
  AgentId: '',
  CategoryId: '',
  CategoryName: '',
  Comment: '',
  Offset: '',
  SegmentId: '',
  UserEmail: '',
  UserName: ''
});

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('AgentId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('CategoryName', '');
encodedParams.set('Comment', '');
encodedParams.set('Offset', '');
encodedParams.set('SegmentId', '');
encodedParams.set('UserEmail', '');
encodedParams.set('UserName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/Comments',
  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('AgentId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('CategoryName', '');
encodedParams.set('Comment', '');
encodedParams.set('Offset', '');
encodedParams.set('SegmentId', '');
encodedParams.set('UserEmail', '');
encodedParams.set('UserName', '');

const url = '{{baseUrl}}/v1/Insights/QM/Assessments/Comments';
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:[@"AgentId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CategoryId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CategoryName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Comment=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Offset=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&SegmentId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UserEmail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UserName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Assessments/Comments"]
                                                       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/Insights/QM/Assessments/Comments" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=" in

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

 "{{baseUrl}}/v1/Insights/QM/Assessments/Comments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=",
  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/Insights/QM/Assessments/Comments', [
  'form_params' => [
    'AgentId' => '',
    'CategoryId' => '',
    'CategoryName' => '',
    'Comment' => '',
    'Offset' => '',
    'SegmentId' => '',
    'UserEmail' => '',
    'UserName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Assessments/Comments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AgentId' => '',
  'CategoryId' => '',
  'CategoryName' => '',
  'Comment' => '',
  'Offset' => '',
  'SegmentId' => '',
  'UserEmail' => '',
  'UserName' => ''
]);

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

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

append(new http\QueryString([
  'AgentId' => '',
  'CategoryId' => '',
  'CategoryName' => '',
  'Comment' => '',
  'Offset' => '',
  'SegmentId' => '',
  'UserEmail' => '',
  'UserName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Assessments/Comments');
$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/Insights/QM/Assessments/Comments' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Assessments/Comments' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName='

import http.client

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

payload = "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName="

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

conn.request("POST", "/baseUrl/v1/Insights/QM/Assessments/Comments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

payload = {
    "AgentId": "",
    "CategoryId": "",
    "CategoryName": "",
    "Comment": "",
    "Offset": "",
    "SegmentId": "",
    "UserEmail": "",
    "UserName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

payload <- "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName="

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/Insights/QM/Assessments/Comments")

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 = "AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName="

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

require 'faraday'

data = {
  :AgentId => "",
  :CategoryId => "",
  :CategoryName => "",
  :Comment => "",
  :Offset => "",
  :SegmentId => "",
  :UserEmail => "",
  :UserName => "",
}

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

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

    let payload = json!({
        "AgentId": "",
        "CategoryId": "",
        "CategoryName": "",
        "Comment": "",
        "Offset": "",
        "SegmentId": "",
        "UserEmail": "",
        "UserName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Assessments/Comments \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AgentId= \
  --data CategoryId= \
  --data CategoryName= \
  --data Comment= \
  --data Offset= \
  --data SegmentId= \
  --data UserEmail= \
  --data UserName=

http --form POST {{baseUrl}}/v1/Insights/QM/Assessments/Comments \
  content-type:application/x-www-form-urlencoded \
  AgentId='' \
  CategoryId='' \
  CategoryName='' \
  Comment='' \
  Offset='' \
  SegmentId='' \
  UserEmail='' \
  UserName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AgentId=&CategoryId=&CategoryName=&Comment=&Offset=&SegmentId=&UserEmail=&UserName=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Assessments/Comments

import Foundation

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

let postData = NSMutableData(data: "AgentId=".data(using: String.Encoding.utf8)!)
postData.append("&CategoryId=".data(using: String.Encoding.utf8)!)
postData.append("&CategoryName=".data(using: String.Encoding.utf8)!)
postData.append("&Comment=".data(using: String.Encoding.utf8)!)
postData.append("&Offset=".data(using: String.Encoding.utf8)!)
postData.append("&SegmentId=".data(using: String.Encoding.utf8)!)
postData.append("&UserEmail=".data(using: String.Encoding.utf8)!)
postData.append("&UserName=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST CreateInsightsQuestionnaires

{{baseUrl}}/v1/Insights/QM/Questionnaires

BODY formUrlEncoded

Active

Description

Name

QuestionIds

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questionnaires");

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, "Active=&Description=&Name=&QuestionIds=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Insights/QM/Questionnaires" {:form-params {:Active ""
                                                                                        :Description ""
                                                                                        :Name ""
                                                                                        :QuestionIds ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Active=&Description=&Name=&QuestionIds="

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/Insights/QM/Questionnaires"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Active", "" },
        { "Description", "" },
        { "Name", "" },
        { "QuestionIds", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questionnaires");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Active=&Description=&Name=&QuestionIds=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questionnaires"

	payload := strings.NewReader("Active=&Description=&Name=&QuestionIds=")

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

Active=&Description=&Name=&QuestionIds=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Questionnaires")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Active=&Description=&Name=&QuestionIds=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Questionnaires")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Active=&Description=&Name=&QuestionIds=")
  .asString();

const data = 'Active=&Description=&Name=&QuestionIds=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Active', '');
encodedParams.set('Description', '');
encodedParams.set('Name', '');
encodedParams.set('QuestionIds', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires',
  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/Insights/QM/Questionnaires';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Active: '', Description: '', Name: '', QuestionIds: ''})
};

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/Insights/QM/Questionnaires',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Active: '',
    Description: '',
    Name: '',
    QuestionIds: ''
  }
};

$.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, "Active=&Description=&Name=&QuestionIds=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questionnaires")
  .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/Insights/QM/Questionnaires',
  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({Active: '', Description: '', Name: '', QuestionIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Active: '', Description: '', Name: '', QuestionIds: ''}
};

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/Insights/QM/Questionnaires');

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

req.form({
  Active: '',
  Description: '',
  Name: '',
  QuestionIds: ''
});

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('Active', '');
encodedParams.set('Description', '');
encodedParams.set('Name', '');
encodedParams.set('QuestionIds', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires',
  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('Active', '');
encodedParams.set('Description', '');
encodedParams.set('Name', '');
encodedParams.set('QuestionIds', '');

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires';
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:[@"Active=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&QuestionIds=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/Insights/QM/Questionnaires",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Active=&Description=&Name=&QuestionIds=",
  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/Insights/QM/Questionnaires', [
  'form_params' => [
    'Active' => '',
    'Description' => '',
    'Name' => '',
    'QuestionIds' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'Active' => '',
  'Description' => '',
  'Name' => '',
  'QuestionIds' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires');
$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/Insights/QM/Questionnaires' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Active=&Description=&Name=&QuestionIds='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Active=&Description=&Name=&QuestionIds='

import http.client

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

payload = "Active=&Description=&Name=&QuestionIds="

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

conn.request("POST", "/baseUrl/v1/Insights/QM/Questionnaires", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questionnaires"

payload <- "Active=&Description=&Name=&QuestionIds="

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/Insights/QM/Questionnaires")

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 = "Active=&Description=&Name=&QuestionIds="

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

require 'faraday'

data = {
  :Active => "",
  :Description => "",
  :Name => "",
  :QuestionIds => "",
}

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

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

    let payload = json!({
        "Active": "",
        "Description": "",
        "Name": "",
        "QuestionIds": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Questionnaires \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Active= \
  --data Description= \
  --data Name= \
  --data QuestionIds=

http --form POST {{baseUrl}}/v1/Insights/QM/Questionnaires \
  content-type:application/x-www-form-urlencoded \
  Active='' \
  Description='' \
  Name='' \
  QuestionIds=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Active=&Description=&Name=&QuestionIds=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questionnaires

import Foundation

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

let postData = NSMutableData(data: "Active=".data(using: String.Encoding.utf8)!)
postData.append("&Description=".data(using: String.Encoding.utf8)!)
postData.append("&Name=".data(using: String.Encoding.utf8)!)
postData.append("&QuestionIds=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST CreateInsightsQuestionnairesCategory

{{baseUrl}}/v1/Insights/QM/Categories

BODY formUrlEncoded

Name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Categories");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Insights/QM/Categories" {:form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Categories"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Name="

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/Insights/QM/Categories"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Categories");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Categories"

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

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

Name=

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Categories")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Name=")
  .asString();

const data = 'Name=';

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

xhr.send(data);

import axios from 'axios';

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

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

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

$.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, "Name=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Categories")
  .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/Insights/QM/Categories',
  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({Name: ''}));
req.end();

const request = require('request');

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

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/Insights/QM/Categories');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Categories',
  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('Name', '');

const url = '{{baseUrl}}/v1/Insights/QM/Categories';
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:[@"Name=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

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

echo $response->getBody();

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

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Categories');
$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/Insights/QM/Categories' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Name='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Categories' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Name='

import http.client

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

payload = "Name="

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

conn.request("POST", "/baseUrl/v1/Insights/QM/Categories", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Categories"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Categories"

payload <- "Name="

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/Insights/QM/Categories")

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

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

require 'faraday'

data = {
  :Name => "",
}

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

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

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Categories \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Name=

http --form POST {{baseUrl}}/v1/Insights/QM/Categories \
  content-type:application/x-www-form-urlencoded \
  Name=''

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

import Foundation

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

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

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

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

dataTask.resume()

POST CreateInsightsQuestionnairesQuestion

{{baseUrl}}/v1/Insights/QM/Questions

BODY formUrlEncoded

AllowNa

AnswerSetId

CategoryId

Description

Question

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questions");

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, "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Insights/QM/Questions" {:form-params {:AllowNa ""
                                                                                   :AnswerSetId ""
                                                                                   :CategoryId ""
                                                                                   :Description ""
                                                                                   :Question ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questions"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

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/Insights/QM/Questions"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AllowNa", "" },
        { "AnswerSetId", "" },
        { "CategoryId", "" },
        { "Description", "" },
        { "Question", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questions"

	payload := strings.NewReader("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")

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

AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Questions")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Questions"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="))
    .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, "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questions")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Questions")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")
  .asString();

const data = 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AllowNa', '');
encodedParams.set('AnswerSetId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('Description', '');
encodedParams.set('Question', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questions',
  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/Insights/QM/Questions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({AllowNa: '', AnswerSetId: '', CategoryId: '', Description: '', Question: ''})
};

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/Insights/QM/Questions',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AllowNa: '',
    AnswerSetId: '',
    CategoryId: '',
    Description: '',
    Question: ''
  }
};

$.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, "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questions")
  .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/Insights/QM/Questions',
  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({AllowNa: '', AnswerSetId: '', CategoryId: '', Description: '', Question: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questions',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {AllowNa: '', AnswerSetId: '', CategoryId: '', Description: '', Question: ''}
};

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/Insights/QM/Questions');

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

req.form({
  AllowNa: '',
  AnswerSetId: '',
  CategoryId: '',
  Description: '',
  Question: ''
});

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('AllowNa', '');
encodedParams.set('AnswerSetId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('Description', '');
encodedParams.set('Question', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questions',
  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('AllowNa', '');
encodedParams.set('AnswerSetId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('Description', '');
encodedParams.set('Question', '');

const url = '{{baseUrl}}/v1/Insights/QM/Questions';
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:[@"AllowNa=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AnswerSetId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CategoryId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Question=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Questions"]
                                                       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/Insights/QM/Questions" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=" in

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

 "{{baseUrl}}/v1/Insights/QM/Questions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=",
  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/Insights/QM/Questions', [
  'form_params' => [
    'AllowNa' => '',
    'AnswerSetId' => '',
    'CategoryId' => '',
    'Description' => '',
    'Question' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'AllowNa' => '',
  'AnswerSetId' => '',
  'CategoryId' => '',
  'Description' => '',
  'Question' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questions');
$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/Insights/QM/Questions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question='

import http.client

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

payload = "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

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

conn.request("POST", "/baseUrl/v1/Insights/QM/Questions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questions"

payload = {
    "AllowNa": "",
    "AnswerSetId": "",
    "CategoryId": "",
    "Description": "",
    "Question": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questions"

payload <- "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

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/Insights/QM/Questions")

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 = "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

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

require 'faraday'

data = {
  :AllowNa => "",
  :AnswerSetId => "",
  :CategoryId => "",
  :Description => "",
  :Question => "",
}

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

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

    let payload = json!({
        "AllowNa": "",
        "AnswerSetId": "",
        "CategoryId": "",
        "Description": "",
        "Question": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Questions \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AllowNa= \
  --data AnswerSetId= \
  --data CategoryId= \
  --data Description= \
  --data Question=

http --form POST {{baseUrl}}/v1/Insights/QM/Questions \
  content-type:application/x-www-form-urlencoded \
  AllowNa='' \
  AnswerSetId='' \
  CategoryId='' \
  Description='' \
  Question=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questions

import Foundation

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

let postData = NSMutableData(data: "AllowNa=".data(using: String.Encoding.utf8)!)
postData.append("&AnswerSetId=".data(using: String.Encoding.utf8)!)
postData.append("&CategoryId=".data(using: String.Encoding.utf8)!)
postData.append("&Description=".data(using: String.Encoding.utf8)!)
postData.append("&Question=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST CreateInsightsSession

{{baseUrl}}/v1/Insights/Session

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Insights/Session")

require "http/client"

url = "{{baseUrl}}/v1/Insights/Session"

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

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

var client = new RestClient("{{baseUrl}}/v1/Insights/Session");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/Session"

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

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

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

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

}

POST /baseUrl/v1/Insights/Session HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/Session")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/Session")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v1/Insights/Session');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/Insights/Session'};

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

const url = '{{baseUrl}}/v1/Insights/Session';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Insights/Session',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/Session")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/Session',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/Insights/Session'};

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

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

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

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

const options = {method: 'POST', url: '{{baseUrl}}/v1/Insights/Session'};

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

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

const url = '{{baseUrl}}/v1/Insights/Session';
const options = {method: 'POST'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Insights/Session" in

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

 "{{baseUrl}}/v1/Insights/Session",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1/Insights/Session');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/v1/Insights/Session');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/Session' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/Session' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/v1/Insights/Session")

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

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

import requests

url = "{{baseUrl}}/v1/Insights/Session"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/Session"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/Session")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/Insights/Session') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/Session

http POST {{baseUrl}}/v1/Insights/Session

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/Insights/Session

import Foundation

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

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

dataTask.resume()

POST CreateInteraction

{{baseUrl}}/v1/Interactions

BODY formUrlEncoded

Channel

Routing

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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, "Channel=&Routing=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Interactions" {:form-params {:Channel ""
                                                                          :Routing ""}})

require "http/client"

url = "{{baseUrl}}/v1/Interactions"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Channel=&Routing="

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/Interactions"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Channel", "" },
        { "Routing", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

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

	payload := strings.NewReader("Channel=&Routing=")

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

Channel=&Routing=

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

client.close();

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

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

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

const data = 'Channel=&Routing=';

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

xhr.send(data);

import axios from 'axios';

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

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

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

$.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, "Channel=&Routing=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions")
  .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/Interactions',
  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({Channel: '', Routing: ''}));
req.end();

const request = require('request');

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

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

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

req.form({
  Channel: '',
  Routing: ''
});

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'Channel' => '',
  'Routing' => ''
]));

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

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

import http.client

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

payload = "Channel=&Routing="

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

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

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

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

import requests

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

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

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

print(response.json())

library(httr)

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

payload <- "Channel=&Routing="

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

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 = "Channel=&Routing="

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

require 'faraday'

data = {
  :Channel => "",
  :Routing => "",
}

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

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

    let payload = json!({
        "Channel": "",
        "Routing": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Interactions \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Channel= \
  --data Routing=

http --form POST {{baseUrl}}/v1/Interactions \
  content-type:application/x-www-form-urlencoded \
  Channel='' \
  Routing=''

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

import Foundation

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

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

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

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

dataTask.resume()

POST CreateInteractionChannelInvite

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites

QUERY PARAMS

InteractionSid

ChannelSid

BODY formUrlEncoded

Routing

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites" {:form-params {:Routing ""}})

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Routing="

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/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Routing", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Routing=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

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

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

Routing=

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Routing=")
  .asString();

const data = 'Routing=';

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

xhr.send(data);

import axios from 'axios';

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

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

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

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Routing: ''})
};

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

$.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, "Routing=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Routing: ''}
};

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Routing=" in

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

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

echo $response->getBody();

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

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Routing='

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

import http.client

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

payload = "Routing="

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

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

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

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

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

payload <- "Routing="

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

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

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

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

require 'faraday'

data = {
  :Routing => "",
}

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

response = conn.post('/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Routing=

http --form POST {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites \
  content-type:application/x-www-form-urlencoded \
  Routing=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Routing= \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites

import Foundation

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

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

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

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

dataTask.resume()

POST CreateInteractionChannelParticipant

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants

QUERY PARAMS

InteractionSid

ChannelSid

BODY formUrlEncoded

MediaProperties

Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "MediaProperties=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants" {:form-params {:MediaProperties ""
                                                                                                                            :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "MediaProperties=&Type="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "MediaProperties", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "MediaProperties=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

	payload := strings.NewReader("MediaProperties=&Type=")

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

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

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

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

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

}

POST /baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 22

MediaProperties=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("MediaProperties=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "MediaProperties=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("MediaProperties=&Type=")
  .asString();

const data = 'MediaProperties=&Type=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

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

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

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({MediaProperties: '', Type: ''})
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    MediaProperties: '',
    Type: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "MediaProperties=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({MediaProperties: '', Type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {MediaProperties: '', Type: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');

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

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "MediaProperties=&Type=" in

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

 "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "MediaProperties=&Type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants', [
  'form_params' => [
    'MediaProperties' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'MediaProperties=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'MediaProperties=&Type='

import http.client

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

payload = "MediaProperties=&Type="

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

conn.request("POST", "/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

payload <- "MediaProperties=&Type="

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")

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

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

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

require 'faraday'

data = {
  :MediaProperties => "",
  :Type => "",
}

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

response = conn.post('/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data MediaProperties= \
  --data Type=

http --form POST {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants \
  content-type:application/x-www-form-urlencoded \
  MediaProperties='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'MediaProperties=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants

import Foundation

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

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

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

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

dataTask.resume()

POST CreateWebChannel

{{baseUrl}}/v1/WebChannels

BODY formUrlEncoded

ChatFriendlyName

ChatUniqueName

CustomerFriendlyName

FlexFlowSid

Identity

PreEngagementData

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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, "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/WebChannels" {:form-params {:ChatFriendlyName ""
                                                                         :ChatUniqueName ""
                                                                         :CustomerFriendlyName ""
                                                                         :FlexFlowSid ""
                                                                         :Identity ""
                                                                         :PreEngagementData ""}})

require "http/client"

url = "{{baseUrl}}/v1/WebChannels"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData="

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/WebChannels"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ChatFriendlyName", "" },
        { "ChatUniqueName", "" },
        { "CustomerFriendlyName", "" },
        { "FlexFlowSid", "" },
        { "Identity", "" },
        { "PreEngagementData", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/WebChannels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=")

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

ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/WebChannels")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/WebChannels")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=")
  .asString();

const data = 'ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=';

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ChatFriendlyName', '');
encodedParams.set('ChatUniqueName', '');
encodedParams.set('CustomerFriendlyName', '');
encodedParams.set('FlexFlowSid', '');
encodedParams.set('Identity', '');
encodedParams.set('PreEngagementData', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/WebChannels',
  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/WebChannels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ChatFriendlyName: '',
    ChatUniqueName: '',
    CustomerFriendlyName: '',
    FlexFlowSid: '',
    Identity: '',
    PreEngagementData: ''
  })
};

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/WebChannels',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ChatFriendlyName: '',
    ChatUniqueName: '',
    CustomerFriendlyName: '',
    FlexFlowSid: '',
    Identity: '',
    PreEngagementData: ''
  }
};

$.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, "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/WebChannels")
  .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/WebChannels',
  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({
  ChatFriendlyName: '',
  ChatUniqueName: '',
  CustomerFriendlyName: '',
  FlexFlowSid: '',
  Identity: '',
  PreEngagementData: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/WebChannels',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ChatFriendlyName: '',
    ChatUniqueName: '',
    CustomerFriendlyName: '',
    FlexFlowSid: '',
    Identity: '',
    PreEngagementData: ''
  }
};

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

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

req.form({
  ChatFriendlyName: '',
  ChatUniqueName: '',
  CustomerFriendlyName: '',
  FlexFlowSid: '',
  Identity: '',
  PreEngagementData: ''
});

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('ChatFriendlyName', '');
encodedParams.set('ChatUniqueName', '');
encodedParams.set('CustomerFriendlyName', '');
encodedParams.set('FlexFlowSid', '');
encodedParams.set('Identity', '');
encodedParams.set('PreEngagementData', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/WebChannels',
  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('ChatFriendlyName', '');
encodedParams.set('ChatUniqueName', '');
encodedParams.set('CustomerFriendlyName', '');
encodedParams.set('FlexFlowSid', '');
encodedParams.set('Identity', '');
encodedParams.set('PreEngagementData', '');

const url = '{{baseUrl}}/v1/WebChannels';
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:[@"ChatFriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatUniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CustomerFriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FlexFlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PreEngagementData=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

 "{{baseUrl}}/v1/WebChannels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=",
  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/WebChannels', [
  'form_params' => [
    'ChatFriendlyName' => '',
    'ChatUniqueName' => '',
    'CustomerFriendlyName' => '',
    'FlexFlowSid' => '',
    'Identity' => '',
    'PreEngagementData' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ChatFriendlyName' => '',
  'ChatUniqueName' => '',
  'CustomerFriendlyName' => '',
  'FlexFlowSid' => '',
  'Identity' => '',
  'PreEngagementData' => ''
]);

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

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

append(new http\QueryString([
  'ChatFriendlyName' => '',
  'ChatUniqueName' => '',
  'CustomerFriendlyName' => '',
  'FlexFlowSid' => '',
  'Identity' => '',
  'PreEngagementData' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/WebChannels');
$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/WebChannels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/WebChannels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData='

import http.client

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

payload = "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData="

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

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

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

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

import requests

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

payload = {
    "ChatFriendlyName": "",
    "ChatUniqueName": "",
    "CustomerFriendlyName": "",
    "FlexFlowSid": "",
    "Identity": "",
    "PreEngagementData": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

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

payload <- "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData="

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

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 = "ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData="

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

require 'faraday'

data = {
  :ChatFriendlyName => "",
  :ChatUniqueName => "",
  :CustomerFriendlyName => "",
  :FlexFlowSid => "",
  :Identity => "",
  :PreEngagementData => "",
}

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

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

    let payload = json!({
        "ChatFriendlyName": "",
        "ChatUniqueName": "",
        "CustomerFriendlyName": "",
        "FlexFlowSid": "",
        "Identity": "",
        "PreEngagementData": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/WebChannels \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ChatFriendlyName= \
  --data ChatUniqueName= \
  --data CustomerFriendlyName= \
  --data FlexFlowSid= \
  --data Identity= \
  --data PreEngagementData=

http --form POST {{baseUrl}}/v1/WebChannels \
  content-type:application/x-www-form-urlencoded \
  ChatFriendlyName='' \
  ChatUniqueName='' \
  CustomerFriendlyName='' \
  FlexFlowSid='' \
  Identity='' \
  PreEngagementData=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChatFriendlyName=&ChatUniqueName=&CustomerFriendlyName=&FlexFlowSid=&Identity=&PreEngagementData=' \
  --output-document \
  - {{baseUrl}}/v1/WebChannels

import Foundation

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

let postData = NSMutableData(data: "ChatFriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&ChatUniqueName=".data(using: String.Encoding.utf8)!)
postData.append("&CustomerFriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&FlexFlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&PreEngagementData=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

DELETE DeleteChannel

{{baseUrl}}/v1/Channels/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/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/Channels/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Channels/:Sid")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/v1/Channels/:Sid') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Channels/:Sid

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

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

import Foundation

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

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

dataTask.resume()

DELETE DeleteFlexFlow

{{baseUrl}}/v1/FlexFlows/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/FlexFlows/:Sid

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

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

import Foundation

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

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

dataTask.resume()

DELETE DeleteInsightsQuestionnaires

{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

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/Insights/QM/Questionnaires/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

	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/Insights/QM/Questionnaires/:Id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id'
};

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

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id';
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/Insights/QM/Questionnaires/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .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/Insights/QM/Questionnaires/:Id',
  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/Insights/QM/Questionnaires/:Id'
};

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/Insights/QM/Questionnaires/:Id');

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/Insights/QM/Questionnaires/:Id'
};

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

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

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id';
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/Insights/QM/Questionnaires/:Id"]
                                                       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/Insights/QM/Questionnaires/:Id" in

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

 "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id",
  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/Insights/QM/Questionnaires/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Insights/QM/Questionnaires/:Id")

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")

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/Insights/QM/Questionnaires/:Id') 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/Insights/QM/Questionnaires/:Id";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

http DELETE {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

import Foundation

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

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

dataTask.resume()

DELETE DeleteInsightsQuestionnairesCategory

{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId

QUERY PARAMS

CategoryId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

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/Insights/QM/Categories/:CategoryId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

	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/Insights/QM/Categories/:CategoryId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId'
};

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

const url = '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId';
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/Insights/QM/Categories/:CategoryId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")
  .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/Insights/QM/Categories/:CategoryId',
  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/Insights/QM/Categories/:CategoryId'
};

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/Insights/QM/Categories/:CategoryId');

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/Insights/QM/Categories/:CategoryId'
};

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

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

const url = '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId';
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/Insights/QM/Categories/:CategoryId"]
                                                       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/Insights/QM/Categories/:CategoryId" in

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

 "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId",
  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/Insights/QM/Categories/:CategoryId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Insights/QM/Categories/:CategoryId")

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")

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/Insights/QM/Categories/:CategoryId') 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/Insights/QM/Categories/:CategoryId";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Insights/QM/Categories/:CategoryId

http DELETE {{baseUrl}}/v1/Insights/QM/Categories/:CategoryId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Categories/:CategoryId

import Foundation

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

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

dataTask.resume()

DELETE DeleteInsightsQuestionnairesQuestion

{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId

QUERY PARAMS

QuestionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

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/Insights/QM/Questions/:QuestionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

	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/Insights/QM/Questions/:QuestionId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId'
};

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

const url = '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId';
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/Insights/QM/Questions/:QuestionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")
  .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/Insights/QM/Questions/:QuestionId',
  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/Insights/QM/Questions/:QuestionId'
};

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/Insights/QM/Questions/:QuestionId');

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/Insights/QM/Questions/:QuestionId'
};

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

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

const url = '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId';
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/Insights/QM/Questions/:QuestionId"]
                                                       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/Insights/QM/Questions/:QuestionId" in

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

 "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId",
  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/Insights/QM/Questions/:QuestionId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Insights/QM/Questions/:QuestionId")

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

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

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")

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/Insights/QM/Questions/:QuestionId') 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/Insights/QM/Questions/:QuestionId";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Insights/QM/Questions/:QuestionId

http DELETE {{baseUrl}}/v1/Insights/QM/Questions/:QuestionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questions/:QuestionId

import Foundation

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

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

dataTask.resume()

DELETE DeleteWebChannel

{{baseUrl}}/v1/WebChannels/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/WebChannels/:Sid

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

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

import Foundation

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

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

dataTask.resume()

GET FetchChannel

{{baseUrl}}/v1/Channels/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Channels/:Sid")

require "http/client"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/Channels/:Sid")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Channels/:Sid

http GET {{baseUrl}}/v1/Channels/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Channels/:Sid

import Foundation

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

GET FetchConfiguration

{{baseUrl}}/v1/Configuration

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Configuration")

require "http/client"

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

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

var client = new RestClient("{{baseUrl}}/v1/Configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

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

const url = '{{baseUrl}}/v1/Configuration';
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/Configuration"]
                                                       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/Configuration" in

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

 "{{baseUrl}}/v1/Configuration",
  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/Configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Configuration")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Configuration

http GET {{baseUrl}}/v1/Configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Configuration

import Foundation

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

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

dataTask.resume()

GET FetchFlexFlow

{{baseUrl}}/v1/FlexFlows/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/FlexFlows/:Sid")

require "http/client"

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/FlexFlows/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/FlexFlows/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/FlexFlows/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/FlexFlows/: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/FlexFlows/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/FlexFlows/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/FlexFlows/:Sid

http GET {{baseUrl}}/v1/FlexFlows/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/FlexFlows/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/FlexFlows/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInsightsQuestionnaires

{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

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/Insights/QM/Questionnaires/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

	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/Insights/QM/Questionnaires/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"))
    .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/Insights/QM/Questionnaires/:Id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .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/Insights/QM/Questionnaires/:Id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id';
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/Insights/QM/Questionnaires/:Id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Questionnaires/:Id',
  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/Insights/QM/Questionnaires/:Id'
};

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/Insights/QM/Questionnaires/:Id');

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/Insights/QM/Questionnaires/:Id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id';
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/Insights/QM/Questionnaires/:Id"]
                                                       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/Insights/QM/Questionnaires/:Id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id",
  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/Insights/QM/Questionnaires/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Questionnaires/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")

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/Insights/QM/Questionnaires/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

http GET {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInsightsSegments

{{baseUrl}}/v1/Insights/Segments/:SegmentId

QUERY PARAMS

SegmentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/Segments/:SegmentId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/Segments/:SegmentId")

require "http/client"

url = "{{baseUrl}}/v1/Insights/Segments/:SegmentId"

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/Insights/Segments/:SegmentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/Segments/:SegmentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/Segments/:SegmentId"

	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/Insights/Segments/:SegmentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/Segments/:SegmentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/Segments/:SegmentId"))
    .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/Insights/Segments/:SegmentId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/Segments/:SegmentId")
  .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/Insights/Segments/:SegmentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Insights/Segments/:SegmentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/Segments/:SegmentId';
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/Insights/Segments/:SegmentId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/Segments/:SegmentId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/Segments/:SegmentId',
  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/Insights/Segments/:SegmentId'
};

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/Insights/Segments/:SegmentId');

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/Insights/Segments/:SegmentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/Segments/:SegmentId';
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/Insights/Segments/:SegmentId"]
                                                       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/Insights/Segments/:SegmentId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/Segments/:SegmentId",
  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/Insights/Segments/:SegmentId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/Segments/:SegmentId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/Segments/:SegmentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/Segments/:SegmentId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/Segments/:SegmentId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/Segments/:SegmentId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/Segments/:SegmentId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/Segments/:SegmentId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/Segments/:SegmentId")

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/Insights/Segments/:SegmentId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/Segments/:SegmentId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/Segments/:SegmentId

http GET {{baseUrl}}/v1/Insights/Segments/:SegmentId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/Segments/:SegmentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/Segments/:SegmentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInsightsSettingsAnswersets

{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets"

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/Insights/QM/Settings/AnswerSets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets"

	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/Insights/QM/Settings/AnswerSets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets"))
    .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/Insights/QM/Settings/AnswerSets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets")
  .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/Insights/QM/Settings/AnswerSets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets';
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/Insights/QM/Settings/AnswerSets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Settings/AnswerSets',
  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/Insights/QM/Settings/AnswerSets'
};

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/Insights/QM/Settings/AnswerSets');

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/Insights/QM/Settings/AnswerSets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets';
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/Insights/QM/Settings/AnswerSets"]
                                                       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/Insights/QM/Settings/AnswerSets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets",
  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/Insights/QM/Settings/AnswerSets');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Settings/AnswerSets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets")

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/Insights/QM/Settings/AnswerSets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Settings/AnswerSets

http GET {{baseUrl}}/v1/Insights/QM/Settings/AnswerSets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Settings/AnswerSets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Settings/AnswerSets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInsightsSettingsComment

{{baseUrl}}/v1/Insights/QM/Settings/CommentTags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags"

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/Insights/QM/Settings/CommentTags"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Settings/CommentTags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags"

	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/Insights/QM/Settings/CommentTags HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Settings/CommentTags"))
    .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/Insights/QM/Settings/CommentTags")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Settings/CommentTags")
  .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/Insights/QM/Settings/CommentTags');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Insights/QM/Settings/CommentTags'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Settings/CommentTags';
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/Insights/QM/Settings/CommentTags',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Settings/CommentTags")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Settings/CommentTags',
  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/Insights/QM/Settings/CommentTags'
};

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/Insights/QM/Settings/CommentTags');

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/Insights/QM/Settings/CommentTags'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Settings/CommentTags';
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/Insights/QM/Settings/CommentTags"]
                                                       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/Insights/QM/Settings/CommentTags" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags",
  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/Insights/QM/Settings/CommentTags');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Settings/CommentTags');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Settings/CommentTags');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Settings/CommentTags' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Settings/CommentTags' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Settings/CommentTags")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Settings/CommentTags")

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/Insights/QM/Settings/CommentTags') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Settings/CommentTags

http GET {{baseUrl}}/v1/Insights/QM/Settings/CommentTags

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Settings/CommentTags

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Settings/CommentTags")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInsightsUserRoles

{{baseUrl}}/v1/Insights/UserRoles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/UserRoles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/UserRoles")

require "http/client"

url = "{{baseUrl}}/v1/Insights/UserRoles"

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/Insights/UserRoles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/UserRoles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/UserRoles"

	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/Insights/UserRoles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/UserRoles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/UserRoles"))
    .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/Insights/UserRoles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/UserRoles")
  .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/Insights/UserRoles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Insights/UserRoles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/UserRoles';
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/Insights/UserRoles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/UserRoles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/UserRoles',
  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/Insights/UserRoles'};

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/Insights/UserRoles');

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/Insights/UserRoles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/UserRoles';
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/Insights/UserRoles"]
                                                       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/Insights/UserRoles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/UserRoles",
  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/Insights/UserRoles');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/UserRoles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/UserRoles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/UserRoles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/UserRoles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/UserRoles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/UserRoles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/UserRoles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/UserRoles")

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/Insights/UserRoles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/UserRoles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/UserRoles

http GET {{baseUrl}}/v1/Insights/UserRoles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/UserRoles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/UserRoles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInteraction

{{baseUrl}}/v1/Interactions/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Interactions/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Interactions/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Interactions/:Sid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Interactions/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Interactions/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Interactions/:Sid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/Interactions/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Interactions/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Interactions/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Interactions/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:Sid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Interactions/:Sid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Interactions/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Interactions/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Interactions/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Interactions/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Interactions/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Interactions/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Interactions/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Interactions/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Interactions/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Interactions/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Interactions/:Sid

http GET {{baseUrl}}/v1/Interactions/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchInteractionChannel

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid

QUERY PARAMS

InteractionSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Interactions/:InteractionSid/Channels/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid

http GET {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:InteractionSid/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()

GET FetchWebChannel

{{baseUrl}}/v1/WebChannels/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/WebChannels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/WebChannels/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/WebChannels/: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/WebChannels/: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/WebChannels/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/WebChannels/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/WebChannels/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/WebChannels/: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/WebChannels/: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/WebChannels/: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/WebChannels/: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/WebChannels/: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/WebChannels/: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/WebChannels/: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/WebChannels/:Sid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/WebChannels/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/WebChannels/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/WebChannels/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/WebChannels/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/WebChannels/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/WebChannels/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/WebChannels/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/WebChannels/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/WebChannels/:Sid

http GET {{baseUrl}}/v1/WebChannels/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/WebChannels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/WebChannels/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListChannel

{{baseUrl}}/v1/Channels

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Channels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Channels")

require "http/client"

url = "{{baseUrl}}/v1/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/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/Channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/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/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/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/Channels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/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/Channels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Channels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/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/Channels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/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/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/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/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/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/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/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/Channels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/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/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Channels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Channels' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Channels' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Channels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/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/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Channels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Channels

http GET {{baseUrl}}/v1/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/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()

GET ListFlexFlow

{{baseUrl}}/v1/FlexFlows

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/FlexFlows");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/FlexFlows")

require "http/client"

url = "{{baseUrl}}/v1/FlexFlows"

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/FlexFlows"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/FlexFlows");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/FlexFlows"

	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/FlexFlows HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/FlexFlows")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/FlexFlows"))
    .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/FlexFlows")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/FlexFlows")
  .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/FlexFlows');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/FlexFlows'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/FlexFlows';
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/FlexFlows',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/FlexFlows")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/FlexFlows',
  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/FlexFlows'};

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/FlexFlows');

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/FlexFlows'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/FlexFlows';
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/FlexFlows"]
                                                       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/FlexFlows" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/FlexFlows",
  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/FlexFlows');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/FlexFlows');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/FlexFlows');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/FlexFlows' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/FlexFlows' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/FlexFlows")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/FlexFlows"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/FlexFlows"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/FlexFlows")

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/FlexFlows') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/FlexFlows";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/FlexFlows

http GET {{baseUrl}}/v1/FlexFlows

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/FlexFlows

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/FlexFlows")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsAssessments

{{baseUrl}}/v1/Insights/QM/Assessments

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Assessments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Assessments")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Assessments"

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/Insights/QM/Assessments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Assessments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Assessments"

	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/Insights/QM/Assessments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Assessments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Assessments"))
    .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/Insights/QM/Assessments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Assessments")
  .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/Insights/QM/Assessments');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Insights/QM/Assessments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Assessments';
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/Insights/QM/Assessments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Assessments',
  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/Insights/QM/Assessments'};

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/Insights/QM/Assessments');

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/Insights/QM/Assessments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Assessments';
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/Insights/QM/Assessments"]
                                                       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/Insights/QM/Assessments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Assessments",
  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/Insights/QM/Assessments');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Assessments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Assessments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Assessments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Assessments' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Assessments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Assessments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Assessments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Assessments")

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/Insights/QM/Assessments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Assessments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Assessments

http GET {{baseUrl}}/v1/Insights/QM/Assessments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Assessments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Assessments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsAssessmentsComment

{{baseUrl}}/v1/Insights/QM/Assessments/Comments

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Assessments/Comments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Assessments/Comments")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

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/Insights/QM/Assessments/Comments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Assessments/Comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

	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/Insights/QM/Assessments/Comments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Assessments/Comments"))
    .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/Insights/QM/Assessments/Comments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .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/Insights/QM/Assessments/Comments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/Comments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Assessments/Comments';
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/Insights/QM/Assessments/Comments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments/Comments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Assessments/Comments',
  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/Insights/QM/Assessments/Comments'
};

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/Insights/QM/Assessments/Comments');

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/Insights/QM/Assessments/Comments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Assessments/Comments';
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/Insights/QM/Assessments/Comments"]
                                                       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/Insights/QM/Assessments/Comments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Assessments/Comments",
  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/Insights/QM/Assessments/Comments');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Assessments/Comments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Assessments/Comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Assessments/Comments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Assessments/Comments' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Assessments/Comments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Assessments/Comments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Assessments/Comments")

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/Insights/QM/Assessments/Comments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Assessments/Comments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Assessments/Comments

http GET {{baseUrl}}/v1/Insights/QM/Assessments/Comments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Assessments/Comments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Assessments/Comments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsConversations

{{baseUrl}}/v1/Insights/Conversations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/Conversations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/Conversations")

require "http/client"

url = "{{baseUrl}}/v1/Insights/Conversations"

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/Insights/Conversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/Conversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/Conversations"

	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/Insights/Conversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/Conversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/Conversations"))
    .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/Insights/Conversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/Conversations")
  .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/Insights/Conversations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Insights/Conversations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/Conversations';
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/Insights/Conversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/Conversations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/Conversations',
  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/Insights/Conversations'};

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/Insights/Conversations');

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/Insights/Conversations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/Conversations';
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/Insights/Conversations"]
                                                       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/Insights/Conversations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/Conversations",
  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/Insights/Conversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/Conversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/Conversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/Conversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/Conversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/Conversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/Conversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/Conversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/Conversations")

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/Insights/Conversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/Conversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/Conversations

http GET {{baseUrl}}/v1/Insights/Conversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/Conversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsQuestionnaires

{{baseUrl}}/v1/Insights/QM/Questionnaires

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questionnaires");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Questionnaires")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires"

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/Insights/QM/Questionnaires"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questionnaires");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questionnaires"

	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/Insights/QM/Questionnaires HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Questionnaires")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Questionnaires"))
    .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/Insights/QM/Questionnaires")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Questionnaires")
  .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/Insights/QM/Questionnaires');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires';
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/Insights/QM/Questionnaires',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questionnaires")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Questionnaires',
  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/Insights/QM/Questionnaires'
};

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/Insights/QM/Questionnaires');

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/Insights/QM/Questionnaires'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires';
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/Insights/QM/Questionnaires"]
                                                       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/Insights/QM/Questionnaires" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Questionnaires",
  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/Insights/QM/Questionnaires');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Questionnaires")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questionnaires"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Questionnaires")

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/Insights/QM/Questionnaires') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Questionnaires";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Questionnaires

http GET {{baseUrl}}/v1/Insights/QM/Questionnaires

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questionnaires

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Questionnaires")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsQuestionnairesCategory

{{baseUrl}}/v1/Insights/QM/Categories

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Categories")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Categories"

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/Insights/QM/Categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Categories"

	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/Insights/QM/Categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Categories"))
    .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/Insights/QM/Categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Categories")
  .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/Insights/QM/Categories');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Insights/QM/Categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Categories';
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/Insights/QM/Categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Categories',
  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/Insights/QM/Categories'};

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/Insights/QM/Categories');

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/Insights/QM/Categories'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Categories';
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/Insights/QM/Categories"]
                                                       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/Insights/QM/Categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Categories",
  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/Insights/QM/Categories');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Categories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Categories' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Categories")

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/Insights/QM/Categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Categories

http GET {{baseUrl}}/v1/Insights/QM/Categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsQuestionnairesQuestion

{{baseUrl}}/v1/Insights/QM/Questions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/QM/Questions")

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questions"

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/Insights/QM/Questions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questions"

	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/Insights/QM/Questions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/QM/Questions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Questions"))
    .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/Insights/QM/Questions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/QM/Questions")
  .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/Insights/QM/Questions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Insights/QM/Questions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/QM/Questions';
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/Insights/QM/Questions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/QM/Questions',
  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/Insights/QM/Questions'};

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/Insights/QM/Questions');

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/Insights/QM/Questions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/QM/Questions';
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/Insights/QM/Questions"]
                                                       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/Insights/QM/Questions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Questions",
  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/Insights/QM/Questions');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/QM/Questions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/QM/Questions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/QM/Questions")

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/Insights/QM/Questions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/QM/Questions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/QM/Questions

http GET {{baseUrl}}/v1/Insights/QM/Questions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Questions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInsightsSegments

{{baseUrl}}/v1/Insights/Segments

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/Segments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Insights/Segments")

require "http/client"

url = "{{baseUrl}}/v1/Insights/Segments"

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/Insights/Segments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/Segments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/Segments"

	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/Insights/Segments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Insights/Segments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/Segments"))
    .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/Insights/Segments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Insights/Segments")
  .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/Insights/Segments');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Insights/Segments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Insights/Segments';
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/Insights/Segments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/Segments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Insights/Segments',
  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/Insights/Segments'};

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/Insights/Segments');

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/Insights/Segments'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Insights/Segments';
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/Insights/Segments"]
                                                       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/Insights/Segments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/Segments",
  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/Insights/Segments');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/Segments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Insights/Segments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Insights/Segments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/Segments' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Insights/Segments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/Segments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/Segments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Insights/Segments")

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/Insights/Segments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Insights/Segments";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Insights/Segments

http GET {{baseUrl}}/v1/Insights/Segments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Insights/Segments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/Segments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInteractionChannel

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels

QUERY PARAMS

InteractionSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels")

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Interactions/:InteractionSid/Channels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/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/Interactions/:InteractionSid/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels

http GET {{baseUrl}}/v1/Interactions/:InteractionSid/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:InteractionSid/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()

GET ListInteractionChannelInvite

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites

QUERY PARAMS

InteractionSid

ChannelSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites

http GET {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Invites")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInteractionChannelParticipant

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants

QUERY PARAMS

InteractionSid

ChannelSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants

http GET {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListWebChannel

{{baseUrl}}/v1/WebChannels

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/WebChannels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/WebChannels")

require "http/client"

url = "{{baseUrl}}/v1/WebChannels"

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/WebChannels"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/WebChannels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/WebChannels"

	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/WebChannels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/WebChannels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/WebChannels"))
    .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/WebChannels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/WebChannels")
  .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/WebChannels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/WebChannels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/WebChannels';
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/WebChannels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/WebChannels")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/WebChannels',
  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/WebChannels'};

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/WebChannels');

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/WebChannels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/WebChannels';
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/WebChannels"]
                                                       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/WebChannels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/WebChannels",
  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/WebChannels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/WebChannels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/WebChannels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/WebChannels' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/WebChannels' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/WebChannels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/WebChannels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/WebChannels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/WebChannels")

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/WebChannels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/WebChannels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/WebChannels

http GET {{baseUrl}}/v1/WebChannels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/WebChannels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/WebChannels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateFlexFlow

{{baseUrl}}/v1/FlexFlows/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

ChannelType

ChatServiceSid

ContactIdentity

Enabled

FriendlyName

Integration.Channel

Integration.CreationOnMessage

Integration.FlowSid

Integration.Priority

Integration.RetryCount

Integration.Timeout

Integration.Url

Integration.WorkflowSid

Integration.WorkspaceSid

IntegrationType

JanitorEnabled

LongLived

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/FlexFlows/: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, "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/FlexFlows/:Sid" {:form-params {:ChannelType ""
                                                                            :ChatServiceSid ""
                                                                            :ContactIdentity ""
                                                                            :Enabled ""
                                                                            :FriendlyName ""
                                                                            :Integration.Channel ""
                                                                            :Integration.CreationOnMessage ""
                                                                            :Integration.FlowSid ""
                                                                            :Integration.Priority ""
                                                                            :Integration.RetryCount ""
                                                                            :Integration.Timeout ""
                                                                            :Integration.Url ""
                                                                            :Integration.WorkflowSid ""
                                                                            :Integration.WorkspaceSid ""
                                                                            :IntegrationType ""
                                                                            :JanitorEnabled ""
                                                                            :LongLived ""}})

require "http/client"

url = "{{baseUrl}}/v1/FlexFlows/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

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/FlexFlows/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ChannelType", "" },
        { "ChatServiceSid", "" },
        { "ContactIdentity", "" },
        { "Enabled", "" },
        { "FriendlyName", "" },
        { "Integration.Channel", "" },
        { "Integration.CreationOnMessage", "" },
        { "Integration.FlowSid", "" },
        { "Integration.Priority", "" },
        { "Integration.RetryCount", "" },
        { "Integration.Timeout", "" },
        { "Integration.Url", "" },
        { "Integration.WorkflowSid", "" },
        { "Integration.WorkspaceSid", "" },
        { "IntegrationType", "" },
        { "JanitorEnabled", "" },
        { "LongLived", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/FlexFlows/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/FlexFlows/:Sid"

	payload := strings.NewReader("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")

	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/FlexFlows/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 320

ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/FlexFlows/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/FlexFlows/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="))
    .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, "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/FlexFlows/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/FlexFlows/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")
  .asString();

const data = 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=';

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/FlexFlows/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ChannelType', '');
encodedParams.set('ChatServiceSid', '');
encodedParams.set('ContactIdentity', '');
encodedParams.set('Enabled', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Integration.Channel', '');
encodedParams.set('Integration.CreationOnMessage', '');
encodedParams.set('Integration.FlowSid', '');
encodedParams.set('Integration.Priority', '');
encodedParams.set('Integration.RetryCount', '');
encodedParams.set('Integration.Timeout', '');
encodedParams.set('Integration.Url', '');
encodedParams.set('Integration.WorkflowSid', '');
encodedParams.set('Integration.WorkspaceSid', '');
encodedParams.set('IntegrationType', '');
encodedParams.set('JanitorEnabled', '');
encodedParams.set('LongLived', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/FlexFlows/: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/FlexFlows/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ChannelType: '',
    ChatServiceSid: '',
    ContactIdentity: '',
    Enabled: '',
    FriendlyName: '',
    'Integration.Channel': '',
    'Integration.CreationOnMessage': '',
    'Integration.FlowSid': '',
    'Integration.Priority': '',
    'Integration.RetryCount': '',
    'Integration.Timeout': '',
    'Integration.Url': '',
    'Integration.WorkflowSid': '',
    'Integration.WorkspaceSid': '',
    IntegrationType: '',
    JanitorEnabled: '',
    LongLived: ''
  })
};

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/FlexFlows/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ChannelType: '',
    ChatServiceSid: '',
    ContactIdentity: '',
    Enabled: '',
    FriendlyName: '',
    'Integration.Channel': '',
    'Integration.CreationOnMessage': '',
    'Integration.FlowSid': '',
    'Integration.Priority': '',
    'Integration.RetryCount': '',
    'Integration.Timeout': '',
    'Integration.Url': '',
    'Integration.WorkflowSid': '',
    'Integration.WorkspaceSid': '',
    IntegrationType: '',
    JanitorEnabled: '',
    LongLived: ''
  }
};

$.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, "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/FlexFlows/: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/FlexFlows/: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({
  ChannelType: '',
  ChatServiceSid: '',
  ContactIdentity: '',
  Enabled: '',
  FriendlyName: '',
  'Integration.Channel': '',
  'Integration.CreationOnMessage': '',
  'Integration.FlowSid': '',
  'Integration.Priority': '',
  'Integration.RetryCount': '',
  'Integration.Timeout': '',
  'Integration.Url': '',
  'Integration.WorkflowSid': '',
  'Integration.WorkspaceSid': '',
  IntegrationType: '',
  JanitorEnabled: '',
  LongLived: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/FlexFlows/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ChannelType: '',
    ChatServiceSid: '',
    ContactIdentity: '',
    Enabled: '',
    FriendlyName: '',
    'Integration.Channel': '',
    'Integration.CreationOnMessage': '',
    'Integration.FlowSid': '',
    'Integration.Priority': '',
    'Integration.RetryCount': '',
    'Integration.Timeout': '',
    'Integration.Url': '',
    'Integration.WorkflowSid': '',
    'Integration.WorkspaceSid': '',
    IntegrationType: '',
    JanitorEnabled: '',
    LongLived: ''
  }
};

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/FlexFlows/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ChannelType: '',
  ChatServiceSid: '',
  ContactIdentity: '',
  Enabled: '',
  FriendlyName: '',
  'Integration.Channel': '',
  'Integration.CreationOnMessage': '',
  'Integration.FlowSid': '',
  'Integration.Priority': '',
  'Integration.RetryCount': '',
  'Integration.Timeout': '',
  'Integration.Url': '',
  'Integration.WorkflowSid': '',
  'Integration.WorkspaceSid': '',
  IntegrationType: '',
  JanitorEnabled: '',
  LongLived: ''
});

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('ChannelType', '');
encodedParams.set('ChatServiceSid', '');
encodedParams.set('ContactIdentity', '');
encodedParams.set('Enabled', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Integration.Channel', '');
encodedParams.set('Integration.CreationOnMessage', '');
encodedParams.set('Integration.FlowSid', '');
encodedParams.set('Integration.Priority', '');
encodedParams.set('Integration.RetryCount', '');
encodedParams.set('Integration.Timeout', '');
encodedParams.set('Integration.Url', '');
encodedParams.set('Integration.WorkflowSid', '');
encodedParams.set('Integration.WorkspaceSid', '');
encodedParams.set('IntegrationType', '');
encodedParams.set('JanitorEnabled', '');
encodedParams.set('LongLived', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/FlexFlows/: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('ChannelType', '');
encodedParams.set('ChatServiceSid', '');
encodedParams.set('ContactIdentity', '');
encodedParams.set('Enabled', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Integration.Channel', '');
encodedParams.set('Integration.CreationOnMessage', '');
encodedParams.set('Integration.FlowSid', '');
encodedParams.set('Integration.Priority', '');
encodedParams.set('Integration.RetryCount', '');
encodedParams.set('Integration.Timeout', '');
encodedParams.set('Integration.Url', '');
encodedParams.set('Integration.WorkflowSid', '');
encodedParams.set('Integration.WorkspaceSid', '');
encodedParams.set('IntegrationType', '');
encodedParams.set('JanitorEnabled', '');
encodedParams.set('LongLived', '');

const url = '{{baseUrl}}/v1/FlexFlows/: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:[@"ChannelType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ChatServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ContactIdentity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Channel=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.CreationOnMessage=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.FlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Priority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.RetryCount=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Timeout=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.WorkflowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Integration.WorkspaceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&IntegrationType=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&JanitorEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LongLived=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/FlexFlows/: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/FlexFlows/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/FlexFlows/: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 => "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=",
  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/FlexFlows/:Sid', [
  'form_params' => [
    'ChannelType' => '',
    'ChatServiceSid' => '',
    'ContactIdentity' => '',
    'Enabled' => '',
    'FriendlyName' => '',
    'Integration.Channel' => '',
    'Integration.CreationOnMessage' => '',
    'Integration.FlowSid' => '',
    'Integration.Priority' => '',
    'Integration.RetryCount' => '',
    'Integration.Timeout' => '',
    'Integration.Url' => '',
    'Integration.WorkflowSid' => '',
    'Integration.WorkspaceSid' => '',
    'IntegrationType' => '',
    'JanitorEnabled' => '',
    'LongLived' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/FlexFlows/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ChannelType' => '',
  'ChatServiceSid' => '',
  'ContactIdentity' => '',
  'Enabled' => '',
  'FriendlyName' => '',
  'Integration.Channel' => '',
  'Integration.CreationOnMessage' => '',
  'Integration.FlowSid' => '',
  'Integration.Priority' => '',
  'Integration.RetryCount' => '',
  'Integration.Timeout' => '',
  'Integration.Url' => '',
  'Integration.WorkflowSid' => '',
  'Integration.WorkspaceSid' => '',
  'IntegrationType' => '',
  'JanitorEnabled' => '',
  'LongLived' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ChannelType' => '',
  'ChatServiceSid' => '',
  'ContactIdentity' => '',
  'Enabled' => '',
  'FriendlyName' => '',
  'Integration.Channel' => '',
  'Integration.CreationOnMessage' => '',
  'Integration.FlowSid' => '',
  'Integration.Priority' => '',
  'Integration.RetryCount' => '',
  'Integration.Timeout' => '',
  'Integration.Url' => '',
  'Integration.WorkflowSid' => '',
  'Integration.WorkspaceSid' => '',
  'IntegrationType' => '',
  'JanitorEnabled' => '',
  'LongLived' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/FlexFlows/: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/FlexFlows/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/FlexFlows/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/FlexFlows/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/FlexFlows/:Sid"

payload = {
    "ChannelType": "",
    "ChatServiceSid": "",
    "ContactIdentity": "",
    "Enabled": "",
    "FriendlyName": "",
    "Integration.Channel": "",
    "Integration.CreationOnMessage": "",
    "Integration.FlowSid": "",
    "Integration.Priority": "",
    "Integration.RetryCount": "",
    "Integration.Timeout": "",
    "Integration.Url": "",
    "Integration.WorkflowSid": "",
    "Integration.WorkspaceSid": "",
    "IntegrationType": "",
    "JanitorEnabled": "",
    "LongLived": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/FlexFlows/:Sid"

payload <- "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

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/FlexFlows/: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 = "ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :ChannelType => "",
  :ChatServiceSid => "",
  :ContactIdentity => "",
  :Enabled => "",
  :FriendlyName => "",
  :Integration.Channel => "",
  :Integration.CreationOnMessage => "",
  :Integration.FlowSid => "",
  :Integration.Priority => "",
  :Integration.RetryCount => "",
  :Integration.Timeout => "",
  :Integration.Url => "",
  :Integration.WorkflowSid => "",
  :Integration.WorkspaceSid => "",
  :IntegrationType => "",
  :JanitorEnabled => "",
  :LongLived => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/FlexFlows/: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/FlexFlows/:Sid";

    let payload = json!({
        "ChannelType": "",
        "ChatServiceSid": "",
        "ContactIdentity": "",
        "Enabled": "",
        "FriendlyName": "",
        "Integration.Channel": "",
        "Integration.CreationOnMessage": "",
        "Integration.FlowSid": "",
        "Integration.Priority": "",
        "Integration.RetryCount": "",
        "Integration.Timeout": "",
        "Integration.Url": "",
        "Integration.WorkflowSid": "",
        "Integration.WorkspaceSid": "",
        "IntegrationType": "",
        "JanitorEnabled": "",
        "LongLived": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/FlexFlows/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ChannelType= \
  --data ChatServiceSid= \
  --data ContactIdentity= \
  --data Enabled= \
  --data FriendlyName= \
  --data Integration.Channel= \
  --data Integration.CreationOnMessage= \
  --data Integration.FlowSid= \
  --data Integration.Priority= \
  --data Integration.RetryCount= \
  --data Integration.Timeout= \
  --data Integration.Url= \
  --data Integration.WorkflowSid= \
  --data Integration.WorkspaceSid= \
  --data IntegrationType= \
  --data JanitorEnabled= \
  --data LongLived=

http --form POST {{baseUrl}}/v1/FlexFlows/:Sid \
  content-type:application/x-www-form-urlencoded \
  ChannelType='' \
  ChatServiceSid='' \
  ContactIdentity='' \
  Enabled='' \
  FriendlyName='' \
  Integration.Channel='' \
  Integration.CreationOnMessage='' \
  Integration.FlowSid='' \
  Integration.Priority='' \
  Integration.RetryCount='' \
  Integration.Timeout='' \
  Integration.Url='' \
  Integration.WorkflowSid='' \
  Integration.WorkspaceSid='' \
  IntegrationType='' \
  JanitorEnabled='' \
  LongLived=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChannelType=&ChatServiceSid=&ContactIdentity=&Enabled=&FriendlyName=&Integration.Channel=&Integration.CreationOnMessage=&Integration.FlowSid=&Integration.Priority=&Integration.RetryCount=&Integration.Timeout=&Integration.Url=&Integration.WorkflowSid=&Integration.WorkspaceSid=&IntegrationType=&JanitorEnabled=&LongLived=' \
  --output-document \
  - {{baseUrl}}/v1/FlexFlows/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ChannelType=".data(using: String.Encoding.utf8)!)
postData.append("&ChatServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&ContactIdentity=".data(using: String.Encoding.utf8)!)
postData.append("&Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Channel=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.CreationOnMessage=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.FlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Priority=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.RetryCount=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Timeout=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.WorkflowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Integration.WorkspaceSid=".data(using: String.Encoding.utf8)!)
postData.append("&IntegrationType=".data(using: String.Encoding.utf8)!)
postData.append("&JanitorEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&LongLived=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/FlexFlows/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateInsightsAssessments

{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId

QUERY PARAMS

AssessmentId

BODY formUrlEncoded

AnswerId

AnswerText

Offset

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId");

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, "AnswerId=&AnswerText=&Offset=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId" {:form-params {:AnswerId ""
                                                                                                   :AnswerText ""
                                                                                                   :Offset ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AnswerId=&AnswerText=&Offset="

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/Insights/QM/Assessments/:AssessmentId"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AnswerId", "" },
        { "AnswerText", "" },
        { "Offset", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AnswerId=&AnswerText=&Offset=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId"

	payload := strings.NewReader("AnswerId=&AnswerText=&Offset=")

	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/Insights/QM/Assessments/:AssessmentId HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 29

AnswerId=&AnswerText=&Offset=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AnswerId=&AnswerText=&Offset=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AnswerId=&AnswerText=&Offset="))
    .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, "AnswerId=&AnswerText=&Offset=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AnswerId=&AnswerText=&Offset=")
  .asString();

const data = 'AnswerId=&AnswerText=&Offset=';

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/Insights/QM/Assessments/:AssessmentId');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AnswerId', '');
encodedParams.set('AnswerText', '');
encodedParams.set('Offset', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId',
  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/Insights/QM/Assessments/:AssessmentId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({AnswerId: '', AnswerText: '', Offset: ''})
};

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/Insights/QM/Assessments/:AssessmentId',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AnswerId: '',
    AnswerText: '',
    Offset: ''
  }
};

$.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, "AnswerId=&AnswerText=&Offset=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId")
  .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/Insights/QM/Assessments/:AssessmentId',
  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({AnswerId: '', AnswerText: '', Offset: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {AnswerId: '', AnswerText: '', Offset: ''}
};

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/Insights/QM/Assessments/:AssessmentId');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AnswerId: '',
  AnswerText: '',
  Offset: ''
});

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('AnswerId', '');
encodedParams.set('AnswerText', '');
encodedParams.set('Offset', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId',
  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('AnswerId', '');
encodedParams.set('AnswerText', '');
encodedParams.set('Offset', '');

const url = '{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId';
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:[@"AnswerId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AnswerText=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Offset=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId"]
                                                       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/Insights/QM/Assessments/:AssessmentId" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AnswerId=&AnswerText=&Offset=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AnswerId=&AnswerText=&Offset=",
  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/Insights/QM/Assessments/:AssessmentId', [
  'form_params' => [
    'AnswerId' => '',
    'AnswerText' => '',
    'Offset' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AnswerId' => '',
  'AnswerText' => '',
  'Offset' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AnswerId' => '',
  'AnswerText' => '',
  'Offset' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId');
$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/Insights/QM/Assessments/:AssessmentId' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AnswerId=&AnswerText=&Offset='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AnswerId=&AnswerText=&Offset='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AnswerId=&AnswerText=&Offset="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Insights/QM/Assessments/:AssessmentId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId"

payload = {
    "AnswerId": "",
    "AnswerText": "",
    "Offset": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId"

payload <- "AnswerId=&AnswerText=&Offset="

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/Insights/QM/Assessments/:AssessmentId")

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 = "AnswerId=&AnswerText=&Offset="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AnswerId => "",
  :AnswerText => "",
  :Offset => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Insights/QM/Assessments/:AssessmentId') 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/Insights/QM/Assessments/:AssessmentId";

    let payload = json!({
        "AnswerId": "",
        "AnswerText": "",
        "Offset": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AnswerId= \
  --data AnswerText= \
  --data Offset=

http --form POST {{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId \
  content-type:application/x-www-form-urlencoded \
  AnswerId='' \
  AnswerText='' \
  Offset=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AnswerId=&AnswerText=&Offset=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AnswerId=".data(using: String.Encoding.utf8)!)
postData.append("&AnswerText=".data(using: String.Encoding.utf8)!)
postData.append("&Offset=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Assessments/:AssessmentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateInsightsQuestionnaires

{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

QUERY PARAMS

BODY formUrlEncoded

Active

Description

Name

QuestionIds

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id");

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, "Active=&Description=&Name=&QuestionIds=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id" {:form-params {:Active ""
                                                                                            :Description ""
                                                                                            :Name ""
                                                                                            :QuestionIds ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Active=&Description=&Name=&QuestionIds="

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/Insights/QM/Questionnaires/:Id"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Active", "" },
        { "Description", "" },
        { "Name", "" },
        { "QuestionIds", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Active=&Description=&Name=&QuestionIds=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

	payload := strings.NewReader("Active=&Description=&Name=&QuestionIds=")

	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/Insights/QM/Questionnaires/:Id HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 39

Active=&Description=&Name=&QuestionIds=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Active=&Description=&Name=&QuestionIds=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Active=&Description=&Name=&QuestionIds="))
    .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, "Active=&Description=&Name=&QuestionIds=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Active=&Description=&Name=&QuestionIds=")
  .asString();

const data = 'Active=&Description=&Name=&QuestionIds=';

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/Insights/QM/Questionnaires/:Id');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Active', '');
encodedParams.set('Description', '');
encodedParams.set('Name', '');
encodedParams.set('QuestionIds', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id',
  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/Insights/QM/Questionnaires/:Id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Active: '', Description: '', Name: '', QuestionIds: ''})
};

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/Insights/QM/Questionnaires/:Id',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Active: '',
    Description: '',
    Name: '',
    QuestionIds: ''
  }
};

$.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, "Active=&Description=&Name=&QuestionIds=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")
  .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/Insights/QM/Questionnaires/:Id',
  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({Active: '', Description: '', Name: '', QuestionIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Active: '', Description: '', Name: '', QuestionIds: ''}
};

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/Insights/QM/Questionnaires/:Id');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Active: '',
  Description: '',
  Name: '',
  QuestionIds: ''
});

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('Active', '');
encodedParams.set('Description', '');
encodedParams.set('Name', '');
encodedParams.set('QuestionIds', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id',
  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('Active', '');
encodedParams.set('Description', '');
encodedParams.set('Name', '');
encodedParams.set('QuestionIds', '');

const url = '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id';
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:[@"Active=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&QuestionIds=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"]
                                                       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/Insights/QM/Questionnaires/:Id" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Active=&Description=&Name=&QuestionIds=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Active=&Description=&Name=&QuestionIds=",
  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/Insights/QM/Questionnaires/:Id', [
  'form_params' => [
    'Active' => '',
    'Description' => '',
    'Name' => '',
    'QuestionIds' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Active' => '',
  'Description' => '',
  'Name' => '',
  'QuestionIds' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Active' => '',
  'Description' => '',
  'Name' => '',
  'QuestionIds' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id');
$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/Insights/QM/Questionnaires/:Id' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Active=&Description=&Name=&QuestionIds='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Active=&Description=&Name=&QuestionIds='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Active=&Description=&Name=&QuestionIds="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Insights/QM/Questionnaires/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

payload = {
    "Active": "",
    "Description": "",
    "Name": "",
    "QuestionIds": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id"

payload <- "Active=&Description=&Name=&QuestionIds="

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/Insights/QM/Questionnaires/:Id")

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 = "Active=&Description=&Name=&QuestionIds="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Active => "",
  :Description => "",
  :Name => "",
  :QuestionIds => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Insights/QM/Questionnaires/:Id') 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/Insights/QM/Questionnaires/:Id";

    let payload = json!({
        "Active": "",
        "Description": "",
        "Name": "",
        "QuestionIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Active= \
  --data Description= \
  --data Name= \
  --data QuestionIds=

http --form POST {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id \
  content-type:application/x-www-form-urlencoded \
  Active='' \
  Description='' \
  Name='' \
  QuestionIds=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Active=&Description=&Name=&QuestionIds=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questionnaires/:Id

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Active=".data(using: String.Encoding.utf8)!)
postData.append("&Description=".data(using: String.Encoding.utf8)!)
postData.append("&Name=".data(using: String.Encoding.utf8)!)
postData.append("&QuestionIds=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Questionnaires/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateInsightsQuestionnairesCategory

{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId

QUERY PARAMS

CategoryId

BODY formUrlEncoded

Name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId");

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, "Name=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId" {:form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Name="

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/Insights/QM/Categories/:CategoryId"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

	payload := strings.NewReader("Name=")

	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/Insights/QM/Categories/:CategoryId HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 5

Name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Name="))
    .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, "Name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Name=")
  .asString();

const data = 'Name=';

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/Insights/QM/Categories/:CategoryId');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId',
  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/Insights/QM/Categories/:CategoryId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Name: ''})
};

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/Insights/QM/Categories/:CategoryId',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Name: ''
  }
};

$.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, "Name=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")
  .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/Insights/QM/Categories/:CategoryId',
  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({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Name: ''}
};

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/Insights/QM/Categories/:CategoryId');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Name: ''
});

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('Name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId',
  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('Name', '');

const url = '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId';
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:[@"Name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"]
                                                       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/Insights/QM/Categories/:CategoryId" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Name=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Name=",
  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/Insights/QM/Categories/:CategoryId', [
  'form_params' => [
    'Name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId');
$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/Insights/QM/Categories/:CategoryId' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Name='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Name='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Name="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Insights/QM/Categories/:CategoryId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

payload = { "Name": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId"

payload <- "Name="

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/Insights/QM/Categories/:CategoryId")

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 = "Name="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Name => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Insights/QM/Categories/:CategoryId') 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/Insights/QM/Categories/:CategoryId";

    let payload = json!({"Name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Categories/:CategoryId \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Name=

http --form POST {{baseUrl}}/v1/Insights/QM/Categories/:CategoryId \
  content-type:application/x-www-form-urlencoded \
  Name=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Name= \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Categories/:CategoryId

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Categories/:CategoryId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateInsightsQuestionnairesQuestion

{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId

QUERY PARAMS

QuestionId

BODY formUrlEncoded

AllowNa

AnswerSetId

CategoryId

Description

Question

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId");

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, "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId" {:form-params {:AllowNa ""
                                                                                               :AnswerSetId ""
                                                                                               :CategoryId ""
                                                                                               :Description ""
                                                                                               :Question ""}})

require "http/client"

url = "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

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/Insights/QM/Questions/:QuestionId"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AllowNa", "" },
        { "AnswerSetId", "" },
        { "CategoryId", "" },
        { "Description", "" },
        { "Question", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

	payload := strings.NewReader("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")

	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/Insights/QM/Questions/:QuestionId HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 56

AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="))
    .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, "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")
  .asString();

const data = 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=';

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/Insights/QM/Questions/:QuestionId');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AllowNa', '');
encodedParams.set('AnswerSetId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('Description', '');
encodedParams.set('Question', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId',
  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/Insights/QM/Questions/:QuestionId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({AllowNa: '', AnswerSetId: '', CategoryId: '', Description: '', Question: ''})
};

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/Insights/QM/Questions/:QuestionId',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    AllowNa: '',
    AnswerSetId: '',
    CategoryId: '',
    Description: '',
    Question: ''
  }
};

$.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, "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")
  .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/Insights/QM/Questions/:QuestionId',
  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({AllowNa: '', AnswerSetId: '', CategoryId: '', Description: '', Question: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {AllowNa: '', AnswerSetId: '', CategoryId: '', Description: '', Question: ''}
};

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/Insights/QM/Questions/:QuestionId');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  AllowNa: '',
  AnswerSetId: '',
  CategoryId: '',
  Description: '',
  Question: ''
});

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('AllowNa', '');
encodedParams.set('AnswerSetId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('Description', '');
encodedParams.set('Question', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId',
  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('AllowNa', '');
encodedParams.set('AnswerSetId', '');
encodedParams.set('CategoryId', '');
encodedParams.set('Description', '');
encodedParams.set('Question', '');

const url = '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId';
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:[@"AllowNa=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AnswerSetId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&CategoryId=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Question=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"]
                                                       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/Insights/QM/Questions/:QuestionId" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=",
  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/Insights/QM/Questions/:QuestionId', [
  'form_params' => [
    'AllowNa' => '',
    'AnswerSetId' => '',
    'CategoryId' => '',
    'Description' => '',
    'Question' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AllowNa' => '',
  'AnswerSetId' => '',
  'CategoryId' => '',
  'Description' => '',
  'Question' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AllowNa' => '',
  'AnswerSetId' => '',
  'CategoryId' => '',
  'Description' => '',
  'Question' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId');
$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/Insights/QM/Questions/:QuestionId' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Insights/QM/Questions/:QuestionId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

payload = {
    "AllowNa": "",
    "AnswerSetId": "",
    "CategoryId": "",
    "Description": "",
    "Question": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId"

payload <- "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

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/Insights/QM/Questions/:QuestionId")

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 = "AllowNa=&AnswerSetId=&CategoryId=&Description=&Question="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AllowNa => "",
  :AnswerSetId => "",
  :CategoryId => "",
  :Description => "",
  :Question => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Insights/QM/Questions/:QuestionId') 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/Insights/QM/Questions/:QuestionId";

    let payload = json!({
        "AllowNa": "",
        "AnswerSetId": "",
        "CategoryId": "",
        "Description": "",
        "Question": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Insights/QM/Questions/:QuestionId \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AllowNa= \
  --data AnswerSetId= \
  --data CategoryId= \
  --data Description= \
  --data Question=

http --form POST {{baseUrl}}/v1/Insights/QM/Questions/:QuestionId \
  content-type:application/x-www-form-urlencoded \
  AllowNa='' \
  AnswerSetId='' \
  CategoryId='' \
  Description='' \
  Question=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AllowNa=&AnswerSetId=&CategoryId=&Description=&Question=' \
  --output-document \
  - {{baseUrl}}/v1/Insights/QM/Questions/:QuestionId

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AllowNa=".data(using: String.Encoding.utf8)!)
postData.append("&AnswerSetId=".data(using: String.Encoding.utf8)!)
postData.append("&CategoryId=".data(using: String.Encoding.utf8)!)
postData.append("&Description=".data(using: String.Encoding.utf8)!)
postData.append("&Question=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Insights/QM/Questions/:QuestionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateInteractionChannel

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid

QUERY PARAMS

InteractionSid

Sid

BODY formUrlEncoded

Routing

Status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Routing=&Status=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid" {:form-params {:Routing ""
                                                                                                        :Status ""}})

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Routing=&Status="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Routing", "" },
        { "Status", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Routing=&Status=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"

	payload := strings.NewReader("Routing=&Status=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Interactions/:InteractionSid/Channels/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 16

Routing=&Status=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Routing=&Status=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Routing=&Status="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Routing=&Status=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Routing=&Status=")
  .asString();

const data = 'Routing=&Status=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Routing', '');
encodedParams.set('Status', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Routing: '', Status: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Routing: '',
    Status: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Routing=&Status=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Interactions/:InteractionSid/Channels/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({Routing: '', Status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Routing: '', Status: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Routing: '',
  Status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Routing', '');
encodedParams.set('Status', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Routing', '');
encodedParams.set('Status', '');

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Routing=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Status=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Routing=&Status=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Routing=&Status=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid', [
  'form_params' => [
    'Routing' => '',
    'Status' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Routing' => '',
  'Status' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Routing' => '',
  'Status' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Routing=&Status='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Routing=&Status='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Routing=&Status="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Interactions/:InteractionSid/Channels/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"

payload = {
    "Routing": "",
    "Status": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid"

payload <- "Routing=&Status="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Routing=&Status="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Routing => "",
  :Status => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Interactions/:InteractionSid/Channels/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid";

    let payload = json!({
        "Routing": "",
        "Status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Routing= \
  --data Status=

http --form POST {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid \
  content-type:application/x-www-form-urlencoded \
  Routing='' \
  Status=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Routing=&Status=' \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Routing=".data(using: String.Encoding.utf8)!)
postData.append("&Status=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateInteractionChannelParticipant

{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid

QUERY PARAMS

InteractionSid

ChannelSid

Sid

BODY formUrlEncoded

Status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Status=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid" {:form-params {:Status ""}})

require "http/client"

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Status="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Status", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Status=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid"

	payload := strings.NewReader("Status=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 7

Status=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Status=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Status="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Status=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Status=")
  .asString();

const data = 'Status=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Status', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/: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/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Status: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Status: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Status=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/: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/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({Status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Status: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Status', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Status', '');

const url = '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Status=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/: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/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Status=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Status=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid', [
  'form_params' => [
    'Status' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Status' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Status' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/: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/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Status='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Status='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Status="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid"

payload = { "Status": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid"

payload <- "Status="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Status="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Status => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/: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/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid";

    let payload = json!({"Status": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Status=

http --form POST {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid \
  content-type:application/x-www-form-urlencoded \
  Status=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Status= \
  --output-document \
  - {{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Status=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Interactions/:InteractionSid/Channels/:ChannelSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateWebChannel

{{baseUrl}}/v1/WebChannels/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

ChatStatus

PostEngagementData

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/WebChannels/: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, "ChatStatus=&PostEngagementData=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/WebChannels/:Sid" {:form-params {:ChatStatus ""
                                                                              :PostEngagementData ""}})

require "http/client"

url = "{{baseUrl}}/v1/WebChannels/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ChatStatus=&PostEngagementData="

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/WebChannels/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ChatStatus", "" },
        { "PostEngagementData", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/WebChannels/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ChatStatus=&PostEngagementData=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/WebChannels/:Sid"

	payload := strings.NewReader("ChatStatus=&PostEngagementData=")

	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/WebChannels/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 31

ChatStatus=&PostEngagementData=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/WebChannels/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ChatStatus=&PostEngagementData=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/WebChannels/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ChatStatus=&PostEngagementData="))
    .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, "ChatStatus=&PostEngagementData=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/WebChannels/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/WebChannels/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ChatStatus=&PostEngagementData=")
  .asString();

const data = 'ChatStatus=&PostEngagementData=';

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/WebChannels/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ChatStatus', '');
encodedParams.set('PostEngagementData', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({ChatStatus: '', PostEngagementData: ''})
};

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/WebChannels/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ChatStatus: '',
    PostEngagementData: ''
  }
};

$.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, "ChatStatus=&PostEngagementData=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/WebChannels/: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/WebChannels/: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({ChatStatus: '', PostEngagementData: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/WebChannels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {ChatStatus: '', PostEngagementData: ''}
};

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/WebChannels/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ChatStatus: '',
  PostEngagementData: ''
});

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('ChatStatus', '');
encodedParams.set('PostEngagementData', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/WebChannels/: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('ChatStatus', '');
encodedParams.set('PostEngagementData', '');

const url = '{{baseUrl}}/v1/WebChannels/: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:[@"ChatStatus=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PostEngagementData=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ChatStatus=&PostEngagementData=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/WebChannels/: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 => "ChatStatus=&PostEngagementData=",
  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/WebChannels/:Sid', [
  'form_params' => [
    'ChatStatus' => '',
    'PostEngagementData' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/WebChannels/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ChatStatus' => '',
  'PostEngagementData' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ChatStatus' => '',
  'PostEngagementData' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/WebChannels/: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/WebChannels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChatStatus=&PostEngagementData='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/WebChannels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ChatStatus=&PostEngagementData='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ChatStatus=&PostEngagementData="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/WebChannels/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/WebChannels/:Sid"

payload = {
    "ChatStatus": "",
    "PostEngagementData": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/WebChannels/:Sid"

payload <- "ChatStatus=&PostEngagementData="

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/WebChannels/: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 = "ChatStatus=&PostEngagementData="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :ChatStatus => "",
  :PostEngagementData => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/WebChannels/: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/WebChannels/:Sid";

    let payload = json!({
        "ChatStatus": "",
        "PostEngagementData": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/WebChannels/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ChatStatus= \
  --data PostEngagementData=

http --form POST {{baseUrl}}/v1/WebChannels/:Sid \
  content-type:application/x-www-form-urlencoded \
  ChatStatus='' \
  PostEngagementData=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ChatStatus=&PostEngagementData=' \
  --output-document \
  - {{baseUrl}}/v1/WebChannels/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ChatStatus=".data(using: String.Encoding.utf8)!)
postData.append("&PostEngagementData=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/WebChannels/: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()