CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id/fallbacks");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels/:id/fallbacks")

require "http/client"

url = "{{baseUrl}}/api/channels/:id/fallbacks"

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}}/api/channels/:id/fallbacks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/:id/fallbacks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/:id/fallbacks"

	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/api/channels/:id/fallbacks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/channels/:id/fallbacks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/:id/fallbacks"))
    .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}}/api/channels/:id/fallbacks")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/channels/:id/fallbacks")
  .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}}/api/channels/:id/fallbacks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels/:id/fallbacks'};

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

const url = '{{baseUrl}}/api/channels/:id/fallbacks';
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}}/api/channels/:id/fallbacks',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id/fallbacks")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/:id/fallbacks',
  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}}/api/channels/:id/fallbacks'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/channels/:id/fallbacks');

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}}/api/channels/:id/fallbacks'};

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

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

const url = '{{baseUrl}}/api/channels/:id/fallbacks';
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}}/api/channels/:id/fallbacks"]
                                                       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}}/api/channels/:id/fallbacks" in

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

 "{{baseUrl}}/api/channels/:id/fallbacks",
  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}}/api/channels/:id/fallbacks');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id/fallbacks');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id/fallbacks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id/fallbacks' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id/fallbacks' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels/:id/fallbacks")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id/fallbacks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id/fallbacks"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/:id/fallbacks")

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/api/channels/:id/fallbacks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/:id/fallbacks";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels/:id/fallbacks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels/:id/fallbacks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/:id/fallbacks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/channels" {:content-type :json
                                                         :form-params {:disableFillerOverlay false
                                                                       :duration ""
                                                                       :fillerCollections [{:id ""
                                                                                            :weight ""
                                                                                            :cooldownSeconds ""}]
                                                                       :fillerRepeatCooldown ""
                                                                       :groupTitle ""
                                                                       :guideFlexTitle ""
                                                                       :guideMinimumDuration ""
                                                                       :icon {:path ""
                                                                              :width ""
                                                                              :duration ""
                                                                              :position ""}
                                                                       :id ""
                                                                       :name ""
                                                                       :number ""
                                                                       :offline {:picture ""
                                                                                 :soundtrack ""
                                                                                 :mode ""}
                                                                       :startTime ""
                                                                       :stealth false
                                                                       :transcoding {:targetResolution ""
                                                                                     :videoBitrate ""
                                                                                     :videoBufferSize ""}
                                                                       :watermark {:url ""
                                                                                   :enabled false
                                                                                   :position ""
                                                                                   :width ""
                                                                                   :verticalMargin ""
                                                                                   :horizontalMargin ""
                                                                                   :duration ""
                                                                                   :fixedSize false
                                                                                   :animated false
                                                                                   :opacity 0
                                                                                   :fadeConfig [{:programType ""
                                                                                                 :periodMins ""
                                                                                                 :leadingEdge false}]}
                                                                       :onDemand {:enabled false}
                                                                       :streamMode ""
                                                                       :transcodeConfigId ""}})

require "http/client"

url = "{{baseUrl}}/api/channels"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

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}}/api/channels"),
    Content = new StringContent("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels"

	payload := strings.NewReader("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/api/channels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1059

{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/channels")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/channels")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/channels")
  .header("content-type", "application/json")
  .body("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  disableFillerOverlay: false,
  duration: '',
  fillerCollections: [
    {
      id: '',
      weight: '',
      cooldownSeconds: ''
    }
  ],
  fillerRepeatCooldown: '',
  groupTitle: '',
  guideFlexTitle: '',
  guideMinimumDuration: '',
  icon: {
    path: '',
    width: '',
    duration: '',
    position: ''
  },
  id: '',
  name: '',
  number: '',
  offline: {
    picture: '',
    soundtrack: '',
    mode: ''
  },
  startTime: '',
  stealth: false,
  transcoding: {
    targetResolution: '',
    videoBitrate: '',
    videoBufferSize: ''
  },
  watermark: {
    url: '',
    enabled: false,
    position: '',
    width: '',
    verticalMargin: '',
    horizontalMargin: '',
    duration: '',
    fixedSize: false,
    animated: false,
    opacity: 0,
    fadeConfig: [
      {
        programType: '',
        periodMins: '',
        leadingEdge: false
      }
    ]
  },
  onDemand: {
    enabled: false
  },
  streamMode: '',
  transcodeConfigId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/api/channels');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/channels',
  headers: {'content-type': 'application/json'},
  data: {
    disableFillerOverlay: false,
    duration: '',
    fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
    fillerRepeatCooldown: '',
    groupTitle: '',
    guideFlexTitle: '',
    guideMinimumDuration: '',
    icon: {path: '', width: '', duration: '', position: ''},
    id: '',
    name: '',
    number: '',
    offline: {picture: '', soundtrack: '', mode: ''},
    startTime: '',
    stealth: false,
    transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
    watermark: {
      url: '',
      enabled: false,
      position: '',
      width: '',
      verticalMargin: '',
      horizontalMargin: '',
      duration: '',
      fixedSize: false,
      animated: false,
      opacity: 0,
      fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
    },
    onDemand: {enabled: false},
    streamMode: '',
    transcodeConfigId: ''
  }
};

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

const url = '{{baseUrl}}/api/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"disableFillerOverlay":false,"duration":"","fillerCollections":[{"id":"","weight":"","cooldownSeconds":""}],"fillerRepeatCooldown":"","groupTitle":"","guideFlexTitle":"","guideMinimumDuration":"","icon":{"path":"","width":"","duration":"","position":""},"id":"","name":"","number":"","offline":{"picture":"","soundtrack":"","mode":""},"startTime":"","stealth":false,"transcoding":{"targetResolution":"","videoBitrate":"","videoBufferSize":""},"watermark":{"url":"","enabled":false,"position":"","width":"","verticalMargin":"","horizontalMargin":"","duration":"","fixedSize":false,"animated":false,"opacity":0,"fadeConfig":[{"programType":"","periodMins":"","leadingEdge":false}]},"onDemand":{"enabled":false},"streamMode":"","transcodeConfigId":""}'
};

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}}/api/channels',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "disableFillerOverlay": false,\n  "duration": "",\n  "fillerCollections": [\n    {\n      "id": "",\n      "weight": "",\n      "cooldownSeconds": ""\n    }\n  ],\n  "fillerRepeatCooldown": "",\n  "groupTitle": "",\n  "guideFlexTitle": "",\n  "guideMinimumDuration": "",\n  "icon": {\n    "path": "",\n    "width": "",\n    "duration": "",\n    "position": ""\n  },\n  "id": "",\n  "name": "",\n  "number": "",\n  "offline": {\n    "picture": "",\n    "soundtrack": "",\n    "mode": ""\n  },\n  "startTime": "",\n  "stealth": false,\n  "transcoding": {\n    "targetResolution": "",\n    "videoBitrate": "",\n    "videoBufferSize": ""\n  },\n  "watermark": {\n    "url": "",\n    "enabled": false,\n    "position": "",\n    "width": "",\n    "verticalMargin": "",\n    "horizontalMargin": "",\n    "duration": "",\n    "fixedSize": false,\n    "animated": false,\n    "opacity": 0,\n    "fadeConfig": [\n      {\n        "programType": "",\n        "periodMins": "",\n        "leadingEdge": false\n      }\n    ]\n  },\n  "onDemand": {\n    "enabled": false\n  },\n  "streamMode": "",\n  "transcodeConfigId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/channels")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({
  disableFillerOverlay: false,
  duration: '',
  fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
  fillerRepeatCooldown: '',
  groupTitle: '',
  guideFlexTitle: '',
  guideMinimumDuration: '',
  icon: {path: '', width: '', duration: '', position: ''},
  id: '',
  name: '',
  number: '',
  offline: {picture: '', soundtrack: '', mode: ''},
  startTime: '',
  stealth: false,
  transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
  watermark: {
    url: '',
    enabled: false,
    position: '',
    width: '',
    verticalMargin: '',
    horizontalMargin: '',
    duration: '',
    fixedSize: false,
    animated: false,
    opacity: 0,
    fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
  },
  onDemand: {enabled: false},
  streamMode: '',
  transcodeConfigId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/channels',
  headers: {'content-type': 'application/json'},
  body: {
    disableFillerOverlay: false,
    duration: '',
    fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
    fillerRepeatCooldown: '',
    groupTitle: '',
    guideFlexTitle: '',
    guideMinimumDuration: '',
    icon: {path: '', width: '', duration: '', position: ''},
    id: '',
    name: '',
    number: '',
    offline: {picture: '', soundtrack: '', mode: ''},
    startTime: '',
    stealth: false,
    transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
    watermark: {
      url: '',
      enabled: false,
      position: '',
      width: '',
      verticalMargin: '',
      horizontalMargin: '',
      duration: '',
      fixedSize: false,
      animated: false,
      opacity: 0,
      fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
    },
    onDemand: {enabled: false},
    streamMode: '',
    transcodeConfigId: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/channels');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  disableFillerOverlay: false,
  duration: '',
  fillerCollections: [
    {
      id: '',
      weight: '',
      cooldownSeconds: ''
    }
  ],
  fillerRepeatCooldown: '',
  groupTitle: '',
  guideFlexTitle: '',
  guideMinimumDuration: '',
  icon: {
    path: '',
    width: '',
    duration: '',
    position: ''
  },
  id: '',
  name: '',
  number: '',
  offline: {
    picture: '',
    soundtrack: '',
    mode: ''
  },
  startTime: '',
  stealth: false,
  transcoding: {
    targetResolution: '',
    videoBitrate: '',
    videoBufferSize: ''
  },
  watermark: {
    url: '',
    enabled: false,
    position: '',
    width: '',
    verticalMargin: '',
    horizontalMargin: '',
    duration: '',
    fixedSize: false,
    animated: false,
    opacity: 0,
    fadeConfig: [
      {
        programType: '',
        periodMins: '',
        leadingEdge: false
      }
    ]
  },
  onDemand: {
    enabled: false
  },
  streamMode: '',
  transcodeConfigId: ''
});

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}}/api/channels',
  headers: {'content-type': 'application/json'},
  data: {
    disableFillerOverlay: false,
    duration: '',
    fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
    fillerRepeatCooldown: '',
    groupTitle: '',
    guideFlexTitle: '',
    guideMinimumDuration: '',
    icon: {path: '', width: '', duration: '', position: ''},
    id: '',
    name: '',
    number: '',
    offline: {picture: '', soundtrack: '', mode: ''},
    startTime: '',
    stealth: false,
    transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
    watermark: {
      url: '',
      enabled: false,
      position: '',
      width: '',
      verticalMargin: '',
      horizontalMargin: '',
      duration: '',
      fixedSize: false,
      animated: false,
      opacity: 0,
      fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
    },
    onDemand: {enabled: false},
    streamMode: '',
    transcodeConfigId: ''
  }
};

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

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

const url = '{{baseUrl}}/api/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"disableFillerOverlay":false,"duration":"","fillerCollections":[{"id":"","weight":"","cooldownSeconds":""}],"fillerRepeatCooldown":"","groupTitle":"","guideFlexTitle":"","guideMinimumDuration":"","icon":{"path":"","width":"","duration":"","position":""},"id":"","name":"","number":"","offline":{"picture":"","soundtrack":"","mode":""},"startTime":"","stealth":false,"transcoding":{"targetResolution":"","videoBitrate":"","videoBufferSize":""},"watermark":{"url":"","enabled":false,"position":"","width":"","verticalMargin":"","horizontalMargin":"","duration":"","fixedSize":false,"animated":false,"opacity":0,"fadeConfig":[{"programType":"","periodMins":"","leadingEdge":false}]},"onDemand":{"enabled":false},"streamMode":"","transcodeConfigId":""}'
};

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/json" };
NSDictionary *parameters = @{ @"disableFillerOverlay": @NO,
                              @"duration": @"",
                              @"fillerCollections": @[ @{ @"id": @"", @"weight": @"", @"cooldownSeconds": @"" } ],
                              @"fillerRepeatCooldown": @"",
                              @"groupTitle": @"",
                              @"guideFlexTitle": @"",
                              @"guideMinimumDuration": @"",
                              @"icon": @{ @"path": @"", @"width": @"", @"duration": @"", @"position": @"" },
                              @"id": @"",
                              @"name": @"",
                              @"number": @"",
                              @"offline": @{ @"picture": @"", @"soundtrack": @"", @"mode": @"" },
                              @"startTime": @"",
                              @"stealth": @NO,
                              @"transcoding": @{ @"targetResolution": @"", @"videoBitrate": @"", @"videoBufferSize": @"" },
                              @"watermark": @{ @"url": @"", @"enabled": @NO, @"position": @"", @"width": @"", @"verticalMargin": @"", @"horizontalMargin": @"", @"duration": @"", @"fixedSize": @NO, @"animated": @NO, @"opacity": @0, @"fadeConfig": @[ @{ @"programType": @"", @"periodMins": @"", @"leadingEdge": @NO } ] },
                              @"onDemand": @{ @"enabled": @NO },
                              @"streamMode": @"",
                              @"transcodeConfigId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/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}}/api/channels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}" in

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

 "{{baseUrl}}/api/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 => json_encode([
    'disableFillerOverlay' => null,
    'duration' => '',
    'fillerCollections' => [
        [
                'id' => '',
                'weight' => '',
                'cooldownSeconds' => ''
        ]
    ],
    'fillerRepeatCooldown' => '',
    'groupTitle' => '',
    'guideFlexTitle' => '',
    'guideMinimumDuration' => '',
    'icon' => [
        'path' => '',
        'width' => '',
        'duration' => '',
        'position' => ''
    ],
    'id' => '',
    'name' => '',
    'number' => '',
    'offline' => [
        'picture' => '',
        'soundtrack' => '',
        'mode' => ''
    ],
    'startTime' => '',
    'stealth' => null,
    'transcoding' => [
        'targetResolution' => '',
        'videoBitrate' => '',
        'videoBufferSize' => ''
    ],
    'watermark' => [
        'url' => '',
        'enabled' => null,
        'position' => '',
        'width' => '',
        'verticalMargin' => '',
        'horizontalMargin' => '',
        'duration' => '',
        'fixedSize' => null,
        'animated' => null,
        'opacity' => 0,
        'fadeConfig' => [
                [
                                'programType' => '',
                                'periodMins' => '',
                                'leadingEdge' => null
                ]
        ]
    ],
    'onDemand' => [
        'enabled' => null
    ],
    'streamMode' => '',
    'transcodeConfigId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/channels', [
  'body' => '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'disableFillerOverlay' => null,
  'duration' => '',
  'fillerCollections' => [
    [
        'id' => '',
        'weight' => '',
        'cooldownSeconds' => ''
    ]
  ],
  'fillerRepeatCooldown' => '',
  'groupTitle' => '',
  'guideFlexTitle' => '',
  'guideMinimumDuration' => '',
  'icon' => [
    'path' => '',
    'width' => '',
    'duration' => '',
    'position' => ''
  ],
  'id' => '',
  'name' => '',
  'number' => '',
  'offline' => [
    'picture' => '',
    'soundtrack' => '',
    'mode' => ''
  ],
  'startTime' => '',
  'stealth' => null,
  'transcoding' => [
    'targetResolution' => '',
    'videoBitrate' => '',
    'videoBufferSize' => ''
  ],
  'watermark' => [
    'url' => '',
    'enabled' => null,
    'position' => '',
    'width' => '',
    'verticalMargin' => '',
    'horizontalMargin' => '',
    'duration' => '',
    'fixedSize' => null,
    'animated' => null,
    'opacity' => 0,
    'fadeConfig' => [
        [
                'programType' => '',
                'periodMins' => '',
                'leadingEdge' => null
        ]
    ]
  ],
  'onDemand' => [
    'enabled' => null
  ],
  'streamMode' => '',
  'transcodeConfigId' => ''
]));

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

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

append(json_encode([
  'disableFillerOverlay' => null,
  'duration' => '',
  'fillerCollections' => [
    [
        'id' => '',
        'weight' => '',
        'cooldownSeconds' => ''
    ]
  ],
  'fillerRepeatCooldown' => '',
  'groupTitle' => '',
  'guideFlexTitle' => '',
  'guideMinimumDuration' => '',
  'icon' => [
    'path' => '',
    'width' => '',
    'duration' => '',
    'position' => ''
  ],
  'id' => '',
  'name' => '',
  'number' => '',
  'offline' => [
    'picture' => '',
    'soundtrack' => '',
    'mode' => ''
  ],
  'startTime' => '',
  'stealth' => null,
  'transcoding' => [
    'targetResolution' => '',
    'videoBitrate' => '',
    'videoBufferSize' => ''
  ],
  'watermark' => [
    'url' => '',
    'enabled' => null,
    'position' => '',
    'width' => '',
    'verticalMargin' => '',
    'horizontalMargin' => '',
    'duration' => '',
    'fixedSize' => null,
    'animated' => null,
    'opacity' => 0,
    'fadeConfig' => [
        [
                'programType' => '',
                'periodMins' => '',
                'leadingEdge' => null
        ]
    ]
  ],
  'onDemand' => [
    'enabled' => null
  ],
  'streamMode' => '',
  'transcodeConfigId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/channels');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}'

import http.client

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

payload = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/channels", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/channels"

payload = {
    "disableFillerOverlay": False,
    "duration": "",
    "fillerCollections": [
        {
            "id": "",
            "weight": "",
            "cooldownSeconds": ""
        }
    ],
    "fillerRepeatCooldown": "",
    "groupTitle": "",
    "guideFlexTitle": "",
    "guideMinimumDuration": "",
    "icon": {
        "path": "",
        "width": "",
        "duration": "",
        "position": ""
    },
    "id": "",
    "name": "",
    "number": "",
    "offline": {
        "picture": "",
        "soundtrack": "",
        "mode": ""
    },
    "startTime": "",
    "stealth": False,
    "transcoding": {
        "targetResolution": "",
        "videoBitrate": "",
        "videoBufferSize": ""
    },
    "watermark": {
        "url": "",
        "enabled": False,
        "position": "",
        "width": "",
        "verticalMargin": "",
        "horizontalMargin": "",
        "duration": "",
        "fixedSize": False,
        "animated": False,
        "opacity": 0,
        "fadeConfig": [
            {
                "programType": "",
                "periodMins": "",
                "leadingEdge": False
            }
        ]
    },
    "onDemand": { "enabled": False },
    "streamMode": "",
    "transcodeConfigId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels"

payload <- "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/channels') do |req|
  req.body = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "disableFillerOverlay": false,
        "duration": "",
        "fillerCollections": (
            json!({
                "id": "",
                "weight": "",
                "cooldownSeconds": ""
            })
        ),
        "fillerRepeatCooldown": "",
        "groupTitle": "",
        "guideFlexTitle": "",
        "guideMinimumDuration": "",
        "icon": json!({
            "path": "",
            "width": "",
            "duration": "",
            "position": ""
        }),
        "id": "",
        "name": "",
        "number": "",
        "offline": json!({
            "picture": "",
            "soundtrack": "",
            "mode": ""
        }),
        "startTime": "",
        "stealth": false,
        "transcoding": json!({
            "targetResolution": "",
            "videoBitrate": "",
            "videoBufferSize": ""
        }),
        "watermark": json!({
            "url": "",
            "enabled": false,
            "position": "",
            "width": "",
            "verticalMargin": "",
            "horizontalMargin": "",
            "duration": "",
            "fixedSize": false,
            "animated": false,
            "opacity": 0,
            "fadeConfig": (
                json!({
                    "programType": "",
                    "periodMins": "",
                    "leadingEdge": false
                })
            )
        }),
        "onDemand": json!({"enabled": false}),
        "streamMode": "",
        "transcodeConfigId": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}' |  \
  http POST {{baseUrl}}/api/channels \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "disableFillerOverlay": false,\n  "duration": "",\n  "fillerCollections": [\n    {\n      "id": "",\n      "weight": "",\n      "cooldownSeconds": ""\n    }\n  ],\n  "fillerRepeatCooldown": "",\n  "groupTitle": "",\n  "guideFlexTitle": "",\n  "guideMinimumDuration": "",\n  "icon": {\n    "path": "",\n    "width": "",\n    "duration": "",\n    "position": ""\n  },\n  "id": "",\n  "name": "",\n  "number": "",\n  "offline": {\n    "picture": "",\n    "soundtrack": "",\n    "mode": ""\n  },\n  "startTime": "",\n  "stealth": false,\n  "transcoding": {\n    "targetResolution": "",\n    "videoBitrate": "",\n    "videoBufferSize": ""\n  },\n  "watermark": {\n    "url": "",\n    "enabled": false,\n    "position": "",\n    "width": "",\n    "verticalMargin": "",\n    "horizontalMargin": "",\n    "duration": "",\n    "fixedSize": false,\n    "animated": false,\n    "opacity": 0,\n    "fadeConfig": [\n      {\n        "programType": "",\n        "periodMins": "",\n        "leadingEdge": false\n      }\n    ]\n  },\n  "onDemand": {\n    "enabled": false\n  },\n  "streamMode": "",\n  "transcodeConfigId": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/channels

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    [
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    ]
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": [
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  ],
  "id": "",
  "name": "",
  "number": "",
  "offline": [
    "picture": "",
    "soundtrack": "",
    "mode": ""
  ],
  "startTime": "",
  "stealth": false,
  "transcoding": [
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  ],
  "watermark": [
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      [
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      ]
    ]
  ],
  "onDemand": ["enabled": false],
  "streamMode": "",
  "transcodeConfigId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/channels/:id")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/api/channels/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/: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/api/channels/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/channels/:id'};

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

const url = '{{baseUrl}}/api/channels/: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}}/api/channels/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/: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/api/channels/: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}}/api/channels/: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}}/api/channels/: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}}/api/channels/:id'};

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

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

const url = '{{baseUrl}}/api/channels/: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}}/api/channels/: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}}/api/channels/:id" in

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

 "{{baseUrl}}/api/channels/: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}}/api/channels/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/api/channels/:id")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/: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/api/channels/: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}}/api/channels/: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);
}

http DELETE {{baseUrl}}/api/channels/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/channels/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id/lineup");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels/:id/lineup")

require "http/client"

url = "{{baseUrl}}/api/channels/:id/lineup"

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}}/api/channels/:id/lineup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/:id/lineup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/:id/lineup"

	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/api/channels/:id/lineup HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/channels/:id/lineup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/:id/lineup"))
    .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}}/api/channels/:id/lineup")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/channels/:id/lineup")
  .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}}/api/channels/:id/lineup');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels/:id/lineup'};

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

const url = '{{baseUrl}}/api/channels/:id/lineup';
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}}/api/channels/:id/lineup',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id/lineup")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/:id/lineup',
  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}}/api/channels/:id/lineup'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/channels/:id/lineup');

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}}/api/channels/:id/lineup'};

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

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

const url = '{{baseUrl}}/api/channels/:id/lineup';
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}}/api/channels/:id/lineup"]
                                                       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}}/api/channels/:id/lineup" in

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

 "{{baseUrl}}/api/channels/:id/lineup",
  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}}/api/channels/:id/lineup');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id/lineup');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id/lineup');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id/lineup' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id/lineup' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels/:id/lineup")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id/lineup"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id/lineup"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/:id/lineup")

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/api/channels/:id/lineup') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/:id/lineup";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels/:id/lineup

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels/:id/lineup

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/:id/lineup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id/programming");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels/:id/programming")

require "http/client"

url = "{{baseUrl}}/api/channels/:id/programming"

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}}/api/channels/:id/programming"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/:id/programming");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/:id/programming"

	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/api/channels/:id/programming HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/channels/:id/programming")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/:id/programming"))
    .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}}/api/channels/:id/programming")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/channels/:id/programming")
  .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}}/api/channels/:id/programming');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels/:id/programming'};

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

const url = '{{baseUrl}}/api/channels/:id/programming';
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}}/api/channels/:id/programming',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id/programming")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/:id/programming',
  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}}/api/channels/:id/programming'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/channels/:id/programming');

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}}/api/channels/:id/programming'};

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

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

const url = '{{baseUrl}}/api/channels/:id/programming';
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}}/api/channels/:id/programming"]
                                                       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}}/api/channels/:id/programming" in

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

 "{{baseUrl}}/api/channels/:id/programming",
  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}}/api/channels/:id/programming');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id/programming');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id/programming');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id/programming' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id/programming' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels/:id/programming")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id/programming"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id/programming"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/:id/programming")

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/api/channels/:id/programming') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/:id/programming";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels/:id/programming

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels/:id/programming

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/:id/programming")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id/programs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels/:id/programs")

require "http/client"

url = "{{baseUrl}}/api/channels/:id/programs"

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}}/api/channels/:id/programs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/:id/programs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/:id/programs"

	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/api/channels/:id/programs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/channels/:id/programs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/:id/programs"))
    .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}}/api/channels/:id/programs")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/channels/:id/programs")
  .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}}/api/channels/:id/programs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels/:id/programs'};

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

const url = '{{baseUrl}}/api/channels/:id/programs';
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}}/api/channels/:id/programs',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id/programs")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/:id/programs',
  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}}/api/channels/:id/programs'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/channels/:id/programs');

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}}/api/channels/:id/programs'};

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

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

const url = '{{baseUrl}}/api/channels/:id/programs';
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}}/api/channels/:id/programs"]
                                                       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}}/api/channels/:id/programs" in

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

 "{{baseUrl}}/api/channels/:id/programs",
  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}}/api/channels/:id/programs');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id/programs');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id/programs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id/programs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id/programs' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels/:id/programs")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id/programs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id/programs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/:id/programs")

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/api/channels/:id/programs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/:id/programs";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels/:id/programs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels/:id/programs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/:id/programs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/all/lineups");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels/all/lineups")

require "http/client"

url = "{{baseUrl}}/api/channels/all/lineups"

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}}/api/channels/all/lineups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/all/lineups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/all/lineups"

	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/api/channels/all/lineups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/channels/all/lineups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/all/lineups"))
    .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}}/api/channels/all/lineups")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/channels/all/lineups")
  .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}}/api/channels/all/lineups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels/all/lineups'};

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

const url = '{{baseUrl}}/api/channels/all/lineups';
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}}/api/channels/all/lineups',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/all/lineups")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/all/lineups',
  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}}/api/channels/all/lineups'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/channels/all/lineups');

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}}/api/channels/all/lineups'};

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

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

const url = '{{baseUrl}}/api/channels/all/lineups';
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}}/api/channels/all/lineups"]
                                                       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}}/api/channels/all/lineups" in

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

 "{{baseUrl}}/api/channels/all/lineups",
  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}}/api/channels/all/lineups');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/all/lineups');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels/all/lineups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/all/lineups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/all/lineups' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels/all/lineups")

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

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

import requests

url = "{{baseUrl}}/api/channels/all/lineups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/all/lineups"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/all/lineups")

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/api/channels/all/lineups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/all/lineups";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels/all/lineups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels/all/lineups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/all/lineups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/helpers/build_guide");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/helpers/build_guide")

require "http/client"

url = "{{baseUrl}}/api/debug/helpers/build_guide"

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}}/api/debug/helpers/build_guide"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/helpers/build_guide");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/helpers/build_guide"

	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/api/debug/helpers/build_guide HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/helpers/build_guide")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/helpers/build_guide"))
    .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}}/api/debug/helpers/build_guide")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/helpers/build_guide")
  .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}}/api/debug/helpers/build_guide');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/helpers/build_guide'
};

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

const url = '{{baseUrl}}/api/debug/helpers/build_guide';
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}}/api/debug/helpers/build_guide',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/helpers/build_guide")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/helpers/build_guide',
  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}}/api/debug/helpers/build_guide'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/helpers/build_guide');

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}}/api/debug/helpers/build_guide'
};

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

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

const url = '{{baseUrl}}/api/debug/helpers/build_guide';
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}}/api/debug/helpers/build_guide"]
                                                       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}}/api/debug/helpers/build_guide" in

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

 "{{baseUrl}}/api/debug/helpers/build_guide",
  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}}/api/debug/helpers/build_guide');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/helpers/build_guide');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/helpers/build_guide');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/helpers/build_guide' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/helpers/build_guide' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/helpers/build_guide")

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

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

import requests

url = "{{baseUrl}}/api/debug/helpers/build_guide"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/helpers/build_guide"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/helpers/build_guide")

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/api/debug/helpers/build_guide') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/helpers/build_guide";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/helpers/build_guide

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/helpers/build_guide

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/helpers/build_guide")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/api/channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/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}}/api/channels")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/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}}/api/channels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels'};

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

const url = '{{baseUrl}}/api/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}}/api/channels',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/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}}/api/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}}/api/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}}/api/channels'};

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

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

const url = '{{baseUrl}}/api/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}}/api/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}}/api/channels" in

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

 "{{baseUrl}}/api/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}}/api/channels');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels")

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

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

import requests

url = "{{baseUrl}}/api/channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/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/api/channels') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/channels/:id")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/api/channels/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/: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/api/channels/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/channels/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/: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}}/api/channels/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/channels/: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}}/api/channels/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/channels/:id'};

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

const url = '{{baseUrl}}/api/channels/: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}}/api/channels/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/: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}}/api/channels/: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}}/api/channels/: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}}/api/channels/:id'};

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

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

const url = '{{baseUrl}}/api/channels/: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}}/api/channels/: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}}/api/channels/:id" in

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

 "{{baseUrl}}/api/channels/: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}}/api/channels/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/channels/:id")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/: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/api/channels/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/channels/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/channels/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id/programming");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/channels/:id/programming")

require "http/client"

url = "{{baseUrl}}/api/channels/:id/programming"

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}}/api/channels/:id/programming"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/:id/programming");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/:id/programming"

	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/api/channels/:id/programming HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/channels/:id/programming")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/:id/programming"))
    .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}}/api/channels/:id/programming")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/channels/:id/programming")
  .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}}/api/channels/:id/programming');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/channels/:id/programming'
};

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

const url = '{{baseUrl}}/api/channels/:id/programming';
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}}/api/channels/:id/programming',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id/programming")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/:id/programming',
  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}}/api/channels/:id/programming'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/channels/:id/programming');

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}}/api/channels/:id/programming'
};

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

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

const url = '{{baseUrl}}/api/channels/:id/programming';
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}}/api/channels/:id/programming"]
                                                       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}}/api/channels/:id/programming" in

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

 "{{baseUrl}}/api/channels/:id/programming",
  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}}/api/channels/:id/programming');

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id/programming');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/api/channels/:id/programming');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id/programming' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id/programming' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/api/channels/:id/programming")

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

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

import requests

url = "{{baseUrl}}/api/channels/:id/programming"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id/programming"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/:id/programming")

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/api/channels/:id/programming') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/:id/programming";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/api/channels/:id/programming

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/channels/:id/programming

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/:id/programming")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/schedule-time-slots");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/channels/schedule-time-slots" {:content-type :json
                                                                             :form-params {:schedule {:type ""
                                                                                                      :flexPreference ""
                                                                                                      :latenessMs ""
                                                                                                      :maxDays ""
                                                                                                      :padMs ""
                                                                                                      :period ""
                                                                                                      :slots [{:order ""
                                                                                                               :direction ""
                                                                                                               :programming ""
                                                                                                               :startTime ""}]
                                                                                                      :timeZoneOffset ""
                                                                                                      :startTomorrow false}
                                                                                           :programs []}})

require "http/client"

url = "{{baseUrl}}/api/channels/schedule-time-slots"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}"

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}}/api/channels/schedule-time-slots"),
    Content = new StringContent("{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/schedule-time-slots");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/schedule-time-slots"

	payload := strings.NewReader("{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/api/channels/schedule-time-slots HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 347

{
  "schedule": {
    "type": "",
    "flexPreference": "",
    "latenessMs": "",
    "maxDays": "",
    "padMs": "",
    "period": "",
    "slots": [
      {
        "order": "",
        "direction": "",
        "programming": "",
        "startTime": ""
      }
    ],
    "timeZoneOffset": "",
    "startTomorrow": false
  },
  "programs": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/channels/schedule-time-slots")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/schedule-time-slots"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/channels/schedule-time-slots")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/channels/schedule-time-slots")
  .header("content-type", "application/json")
  .body("{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}")
  .asString();

const data = JSON.stringify({
  schedule: {
    type: '',
    flexPreference: '',
    latenessMs: '',
    maxDays: '',
    padMs: '',
    period: '',
    slots: [
      {
        order: '',
        direction: '',
        programming: '',
        startTime: ''
      }
    ],
    timeZoneOffset: '',
    startTomorrow: false
  },
  programs: []
});

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

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

xhr.open('POST', '{{baseUrl}}/api/channels/schedule-time-slots');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/channels/schedule-time-slots',
  headers: {'content-type': 'application/json'},
  data: {
    schedule: {
      type: '',
      flexPreference: '',
      latenessMs: '',
      maxDays: '',
      padMs: '',
      period: '',
      slots: [{order: '', direction: '', programming: '', startTime: ''}],
      timeZoneOffset: '',
      startTomorrow: false
    },
    programs: []
  }
};

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

const url = '{{baseUrl}}/api/channels/schedule-time-slots';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"schedule":{"type":"","flexPreference":"","latenessMs":"","maxDays":"","padMs":"","period":"","slots":[{"order":"","direction":"","programming":"","startTime":""}],"timeZoneOffset":"","startTomorrow":false},"programs":[]}'
};

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}}/api/channels/schedule-time-slots',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "schedule": {\n    "type": "",\n    "flexPreference": "",\n    "latenessMs": "",\n    "maxDays": "",\n    "padMs": "",\n    "period": "",\n    "slots": [\n      {\n        "order": "",\n        "direction": "",\n        "programming": "",\n        "startTime": ""\n      }\n    ],\n    "timeZoneOffset": "",\n    "startTomorrow": false\n  },\n  "programs": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/schedule-time-slots")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/schedule-time-slots',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({
  schedule: {
    type: '',
    flexPreference: '',
    latenessMs: '',
    maxDays: '',
    padMs: '',
    period: '',
    slots: [{order: '', direction: '', programming: '', startTime: ''}],
    timeZoneOffset: '',
    startTomorrow: false
  },
  programs: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/channels/schedule-time-slots',
  headers: {'content-type': 'application/json'},
  body: {
    schedule: {
      type: '',
      flexPreference: '',
      latenessMs: '',
      maxDays: '',
      padMs: '',
      period: '',
      slots: [{order: '', direction: '', programming: '', startTime: ''}],
      timeZoneOffset: '',
      startTomorrow: false
    },
    programs: []
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/channels/schedule-time-slots');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  schedule: {
    type: '',
    flexPreference: '',
    latenessMs: '',
    maxDays: '',
    padMs: '',
    period: '',
    slots: [
      {
        order: '',
        direction: '',
        programming: '',
        startTime: ''
      }
    ],
    timeZoneOffset: '',
    startTomorrow: false
  },
  programs: []
});

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}}/api/channels/schedule-time-slots',
  headers: {'content-type': 'application/json'},
  data: {
    schedule: {
      type: '',
      flexPreference: '',
      latenessMs: '',
      maxDays: '',
      padMs: '',
      period: '',
      slots: [{order: '', direction: '', programming: '', startTime: ''}],
      timeZoneOffset: '',
      startTomorrow: false
    },
    programs: []
  }
};

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

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

const url = '{{baseUrl}}/api/channels/schedule-time-slots';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"schedule":{"type":"","flexPreference":"","latenessMs":"","maxDays":"","padMs":"","period":"","slots":[{"order":"","direction":"","programming":"","startTime":""}],"timeZoneOffset":"","startTomorrow":false},"programs":[]}'
};

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/json" };
NSDictionary *parameters = @{ @"schedule": @{ @"type": @"", @"flexPreference": @"", @"latenessMs": @"", @"maxDays": @"", @"padMs": @"", @"period": @"", @"slots": @[ @{ @"order": @"", @"direction": @"", @"programming": @"", @"startTime": @"" } ], @"timeZoneOffset": @"", @"startTomorrow": @NO },
                              @"programs": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/channels/schedule-time-slots"]
                                                       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}}/api/channels/schedule-time-slots" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}" in

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

 "{{baseUrl}}/api/channels/schedule-time-slots",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'schedule' => [
        'type' => '',
        'flexPreference' => '',
        'latenessMs' => '',
        'maxDays' => '',
        'padMs' => '',
        'period' => '',
        'slots' => [
                [
                                'order' => '',
                                'direction' => '',
                                'programming' => '',
                                'startTime' => ''
                ]
        ],
        'timeZoneOffset' => '',
        'startTomorrow' => null
    ],
    'programs' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/channels/schedule-time-slots', [
  'body' => '{
  "schedule": {
    "type": "",
    "flexPreference": "",
    "latenessMs": "",
    "maxDays": "",
    "padMs": "",
    "period": "",
    "slots": [
      {
        "order": "",
        "direction": "",
        "programming": "",
        "startTime": ""
      }
    ],
    "timeZoneOffset": "",
    "startTomorrow": false
  },
  "programs": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/schedule-time-slots');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'schedule' => [
    'type' => '',
    'flexPreference' => '',
    'latenessMs' => '',
    'maxDays' => '',
    'padMs' => '',
    'period' => '',
    'slots' => [
        [
                'order' => '',
                'direction' => '',
                'programming' => '',
                'startTime' => ''
        ]
    ],
    'timeZoneOffset' => '',
    'startTomorrow' => null
  ],
  'programs' => [
    
  ]
]));

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

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

append(json_encode([
  'schedule' => [
    'type' => '',
    'flexPreference' => '',
    'latenessMs' => '',
    'maxDays' => '',
    'padMs' => '',
    'period' => '',
    'slots' => [
        [
                'order' => '',
                'direction' => '',
                'programming' => '',
                'startTime' => ''
        ]
    ],
    'timeZoneOffset' => '',
    'startTomorrow' => null
  ],
  'programs' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/channels/schedule-time-slots');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/schedule-time-slots' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "schedule": {
    "type": "",
    "flexPreference": "",
    "latenessMs": "",
    "maxDays": "",
    "padMs": "",
    "period": "",
    "slots": [
      {
        "order": "",
        "direction": "",
        "programming": "",
        "startTime": ""
      }
    ],
    "timeZoneOffset": "",
    "startTomorrow": false
  },
  "programs": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/schedule-time-slots' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "schedule": {
    "type": "",
    "flexPreference": "",
    "latenessMs": "",
    "maxDays": "",
    "padMs": "",
    "period": "",
    "slots": [
      {
        "order": "",
        "direction": "",
        "programming": "",
        "startTime": ""
      }
    ],
    "timeZoneOffset": "",
    "startTomorrow": false
  },
  "programs": []
}'

import http.client

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

payload = "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/channels/schedule-time-slots", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/channels/schedule-time-slots"

payload = {
    "schedule": {
        "type": "",
        "flexPreference": "",
        "latenessMs": "",
        "maxDays": "",
        "padMs": "",
        "period": "",
        "slots": [
            {
                "order": "",
                "direction": "",
                "programming": "",
                "startTime": ""
            }
        ],
        "timeZoneOffset": "",
        "startTomorrow": False
    },
    "programs": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/schedule-time-slots"

payload <- "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/schedule-time-slots")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/channels/schedule-time-slots') do |req|
  req.body = "{\n  \"schedule\": {\n    \"type\": \"\",\n    \"flexPreference\": \"\",\n    \"latenessMs\": \"\",\n    \"maxDays\": \"\",\n    \"padMs\": \"\",\n    \"period\": \"\",\n    \"slots\": [\n      {\n        \"order\": \"\",\n        \"direction\": \"\",\n        \"programming\": \"\",\n        \"startTime\": \"\"\n      }\n    ],\n    \"timeZoneOffset\": \"\",\n    \"startTomorrow\": false\n  },\n  \"programs\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/channels/schedule-time-slots";

    let payload = json!({
        "schedule": json!({
            "type": "",
            "flexPreference": "",
            "latenessMs": "",
            "maxDays": "",
            "padMs": "",
            "period": "",
            "slots": (
                json!({
                    "order": "",
                    "direction": "",
                    "programming": "",
                    "startTime": ""
                })
            ),
            "timeZoneOffset": "",
            "startTomorrow": false
        }),
        "programs": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "schedule": {
    "type": "",
    "flexPreference": "",
    "latenessMs": "",
    "maxDays": "",
    "padMs": "",
    "period": "",
    "slots": [
      {
        "order": "",
        "direction": "",
        "programming": "",
        "startTime": ""
      }
    ],
    "timeZoneOffset": "",
    "startTomorrow": false
  },
  "programs": []
}' |  \
  http POST {{baseUrl}}/api/channels/schedule-time-slots \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "schedule": {\n    "type": "",\n    "flexPreference": "",\n    "latenessMs": "",\n    "maxDays": "",\n    "padMs": "",\n    "period": "",\n    "slots": [\n      {\n        "order": "",\n        "direction": "",\n        "programming": "",\n        "startTime": ""\n      }\n    ],\n    "timeZoneOffset": "",\n    "startTomorrow": false\n  },\n  "programs": []\n}' \
  --output-document \
  - {{baseUrl}}/api/channels/schedule-time-slots

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "schedule": [
    "type": "",
    "flexPreference": "",
    "latenessMs": "",
    "maxDays": "",
    "padMs": "",
    "period": "",
    "slots": [
      [
        "order": "",
        "direction": "",
        "programming": "",
        "startTime": ""
      ]
    ],
    "timeZoneOffset": "",
    "startTomorrow": false
  ],
  "programs": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/channels/schedule-time-slots")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/channels/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/channels/:id" {:content-type :json
                                                            :form-params {:disableFillerOverlay false
                                                                          :duration ""
                                                                          :fillerCollections [{:id ""
                                                                                               :weight ""
                                                                                               :cooldownSeconds ""}]
                                                                          :fillerRepeatCooldown ""
                                                                          :groupTitle ""
                                                                          :guideFlexTitle ""
                                                                          :guideMinimumDuration ""
                                                                          :icon {:path ""
                                                                                 :width ""
                                                                                 :duration ""
                                                                                 :position ""}
                                                                          :id ""
                                                                          :name ""
                                                                          :number ""
                                                                          :offline {:picture ""
                                                                                    :soundtrack ""
                                                                                    :mode ""}
                                                                          :startTime ""
                                                                          :stealth false
                                                                          :transcoding {:targetResolution ""
                                                                                        :videoBitrate ""
                                                                                        :videoBufferSize ""}
                                                                          :watermark {:url ""
                                                                                      :enabled false
                                                                                      :position ""
                                                                                      :width ""
                                                                                      :verticalMargin ""
                                                                                      :horizontalMargin ""
                                                                                      :duration ""
                                                                                      :fixedSize false
                                                                                      :animated false
                                                                                      :opacity 0
                                                                                      :fadeConfig [{:programType ""
                                                                                                    :periodMins ""
                                                                                                    :leadingEdge false}]}
                                                                          :onDemand {:enabled false}
                                                                          :streamMode ""
                                                                          :transcodeConfigId ""}})

require "http/client"

url = "{{baseUrl}}/api/channels/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/channels/:id"),
    Content = new StringContent("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/channels/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/channels/:id"

	payload := strings.NewReader("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/api/channels/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1059

{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/channels/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/channels/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/channels/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/channels/:id")
  .header("content-type", "application/json")
  .body("{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  disableFillerOverlay: false,
  duration: '',
  fillerCollections: [
    {
      id: '',
      weight: '',
      cooldownSeconds: ''
    }
  ],
  fillerRepeatCooldown: '',
  groupTitle: '',
  guideFlexTitle: '',
  guideMinimumDuration: '',
  icon: {
    path: '',
    width: '',
    duration: '',
    position: ''
  },
  id: '',
  name: '',
  number: '',
  offline: {
    picture: '',
    soundtrack: '',
    mode: ''
  },
  startTime: '',
  stealth: false,
  transcoding: {
    targetResolution: '',
    videoBitrate: '',
    videoBufferSize: ''
  },
  watermark: {
    url: '',
    enabled: false,
    position: '',
    width: '',
    verticalMargin: '',
    horizontalMargin: '',
    duration: '',
    fixedSize: false,
    animated: false,
    opacity: 0,
    fadeConfig: [
      {
        programType: '',
        periodMins: '',
        leadingEdge: false
      }
    ]
  },
  onDemand: {
    enabled: false
  },
  streamMode: '',
  transcodeConfigId: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/channels/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/channels/:id',
  headers: {'content-type': 'application/json'},
  data: {
    disableFillerOverlay: false,
    duration: '',
    fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
    fillerRepeatCooldown: '',
    groupTitle: '',
    guideFlexTitle: '',
    guideMinimumDuration: '',
    icon: {path: '', width: '', duration: '', position: ''},
    id: '',
    name: '',
    number: '',
    offline: {picture: '', soundtrack: '', mode: ''},
    startTime: '',
    stealth: false,
    transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
    watermark: {
      url: '',
      enabled: false,
      position: '',
      width: '',
      verticalMargin: '',
      horizontalMargin: '',
      duration: '',
      fixedSize: false,
      animated: false,
      opacity: 0,
      fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
    },
    onDemand: {enabled: false},
    streamMode: '',
    transcodeConfigId: ''
  }
};

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

const url = '{{baseUrl}}/api/channels/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"disableFillerOverlay":false,"duration":"","fillerCollections":[{"id":"","weight":"","cooldownSeconds":""}],"fillerRepeatCooldown":"","groupTitle":"","guideFlexTitle":"","guideMinimumDuration":"","icon":{"path":"","width":"","duration":"","position":""},"id":"","name":"","number":"","offline":{"picture":"","soundtrack":"","mode":""},"startTime":"","stealth":false,"transcoding":{"targetResolution":"","videoBitrate":"","videoBufferSize":""},"watermark":{"url":"","enabled":false,"position":"","width":"","verticalMargin":"","horizontalMargin":"","duration":"","fixedSize":false,"animated":false,"opacity":0,"fadeConfig":[{"programType":"","periodMins":"","leadingEdge":false}]},"onDemand":{"enabled":false},"streamMode":"","transcodeConfigId":""}'
};

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}}/api/channels/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "disableFillerOverlay": false,\n  "duration": "",\n  "fillerCollections": [\n    {\n      "id": "",\n      "weight": "",\n      "cooldownSeconds": ""\n    }\n  ],\n  "fillerRepeatCooldown": "",\n  "groupTitle": "",\n  "guideFlexTitle": "",\n  "guideMinimumDuration": "",\n  "icon": {\n    "path": "",\n    "width": "",\n    "duration": "",\n    "position": ""\n  },\n  "id": "",\n  "name": "",\n  "number": "",\n  "offline": {\n    "picture": "",\n    "soundtrack": "",\n    "mode": ""\n  },\n  "startTime": "",\n  "stealth": false,\n  "transcoding": {\n    "targetResolution": "",\n    "videoBitrate": "",\n    "videoBufferSize": ""\n  },\n  "watermark": {\n    "url": "",\n    "enabled": false,\n    "position": "",\n    "width": "",\n    "verticalMargin": "",\n    "horizontalMargin": "",\n    "duration": "",\n    "fixedSize": false,\n    "animated": false,\n    "opacity": 0,\n    "fadeConfig": [\n      {\n        "programType": "",\n        "periodMins": "",\n        "leadingEdge": false\n      }\n    ]\n  },\n  "onDemand": {\n    "enabled": false\n  },\n  "streamMode": "",\n  "transcodeConfigId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/channels/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/channels/:id',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({
  disableFillerOverlay: false,
  duration: '',
  fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
  fillerRepeatCooldown: '',
  groupTitle: '',
  guideFlexTitle: '',
  guideMinimumDuration: '',
  icon: {path: '', width: '', duration: '', position: ''},
  id: '',
  name: '',
  number: '',
  offline: {picture: '', soundtrack: '', mode: ''},
  startTime: '',
  stealth: false,
  transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
  watermark: {
    url: '',
    enabled: false,
    position: '',
    width: '',
    verticalMargin: '',
    horizontalMargin: '',
    duration: '',
    fixedSize: false,
    animated: false,
    opacity: 0,
    fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
  },
  onDemand: {enabled: false},
  streamMode: '',
  transcodeConfigId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/channels/:id',
  headers: {'content-type': 'application/json'},
  body: {
    disableFillerOverlay: false,
    duration: '',
    fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
    fillerRepeatCooldown: '',
    groupTitle: '',
    guideFlexTitle: '',
    guideMinimumDuration: '',
    icon: {path: '', width: '', duration: '', position: ''},
    id: '',
    name: '',
    number: '',
    offline: {picture: '', soundtrack: '', mode: ''},
    startTime: '',
    stealth: false,
    transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
    watermark: {
      url: '',
      enabled: false,
      position: '',
      width: '',
      verticalMargin: '',
      horizontalMargin: '',
      duration: '',
      fixedSize: false,
      animated: false,
      opacity: 0,
      fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
    },
    onDemand: {enabled: false},
    streamMode: '',
    transcodeConfigId: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/channels/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  disableFillerOverlay: false,
  duration: '',
  fillerCollections: [
    {
      id: '',
      weight: '',
      cooldownSeconds: ''
    }
  ],
  fillerRepeatCooldown: '',
  groupTitle: '',
  guideFlexTitle: '',
  guideMinimumDuration: '',
  icon: {
    path: '',
    width: '',
    duration: '',
    position: ''
  },
  id: '',
  name: '',
  number: '',
  offline: {
    picture: '',
    soundtrack: '',
    mode: ''
  },
  startTime: '',
  stealth: false,
  transcoding: {
    targetResolution: '',
    videoBitrate: '',
    videoBufferSize: ''
  },
  watermark: {
    url: '',
    enabled: false,
    position: '',
    width: '',
    verticalMargin: '',
    horizontalMargin: '',
    duration: '',
    fixedSize: false,
    animated: false,
    opacity: 0,
    fadeConfig: [
      {
        programType: '',
        periodMins: '',
        leadingEdge: false
      }
    ]
  },
  onDemand: {
    enabled: false
  },
  streamMode: '',
  transcodeConfigId: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/channels/:id',
  headers: {'content-type': 'application/json'},
  data: {
    disableFillerOverlay: false,
    duration: '',
    fillerCollections: [{id: '', weight: '', cooldownSeconds: ''}],
    fillerRepeatCooldown: '',
    groupTitle: '',
    guideFlexTitle: '',
    guideMinimumDuration: '',
    icon: {path: '', width: '', duration: '', position: ''},
    id: '',
    name: '',
    number: '',
    offline: {picture: '', soundtrack: '', mode: ''},
    startTime: '',
    stealth: false,
    transcoding: {targetResolution: '', videoBitrate: '', videoBufferSize: ''},
    watermark: {
      url: '',
      enabled: false,
      position: '',
      width: '',
      verticalMargin: '',
      horizontalMargin: '',
      duration: '',
      fixedSize: false,
      animated: false,
      opacity: 0,
      fadeConfig: [{programType: '', periodMins: '', leadingEdge: false}]
    },
    onDemand: {enabled: false},
    streamMode: '',
    transcodeConfigId: ''
  }
};

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

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

const url = '{{baseUrl}}/api/channels/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"disableFillerOverlay":false,"duration":"","fillerCollections":[{"id":"","weight":"","cooldownSeconds":""}],"fillerRepeatCooldown":"","groupTitle":"","guideFlexTitle":"","guideMinimumDuration":"","icon":{"path":"","width":"","duration":"","position":""},"id":"","name":"","number":"","offline":{"picture":"","soundtrack":"","mode":""},"startTime":"","stealth":false,"transcoding":{"targetResolution":"","videoBitrate":"","videoBufferSize":""},"watermark":{"url":"","enabled":false,"position":"","width":"","verticalMargin":"","horizontalMargin":"","duration":"","fixedSize":false,"animated":false,"opacity":0,"fadeConfig":[{"programType":"","periodMins":"","leadingEdge":false}]},"onDemand":{"enabled":false},"streamMode":"","transcodeConfigId":""}'
};

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/json" };
NSDictionary *parameters = @{ @"disableFillerOverlay": @NO,
                              @"duration": @"",
                              @"fillerCollections": @[ @{ @"id": @"", @"weight": @"", @"cooldownSeconds": @"" } ],
                              @"fillerRepeatCooldown": @"",
                              @"groupTitle": @"",
                              @"guideFlexTitle": @"",
                              @"guideMinimumDuration": @"",
                              @"icon": @{ @"path": @"", @"width": @"", @"duration": @"", @"position": @"" },
                              @"id": @"",
                              @"name": @"",
                              @"number": @"",
                              @"offline": @{ @"picture": @"", @"soundtrack": @"", @"mode": @"" },
                              @"startTime": @"",
                              @"stealth": @NO,
                              @"transcoding": @{ @"targetResolution": @"", @"videoBitrate": @"", @"videoBufferSize": @"" },
                              @"watermark": @{ @"url": @"", @"enabled": @NO, @"position": @"", @"width": @"", @"verticalMargin": @"", @"horizontalMargin": @"", @"duration": @"", @"fixedSize": @NO, @"animated": @NO, @"opacity": @0, @"fadeConfig": @[ @{ @"programType": @"", @"periodMins": @"", @"leadingEdge": @NO } ] },
                              @"onDemand": @{ @"enabled": @NO },
                              @"streamMode": @"",
                              @"transcodeConfigId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/channels/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/api/channels/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}" in

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

 "{{baseUrl}}/api/channels/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'disableFillerOverlay' => null,
    'duration' => '',
    'fillerCollections' => [
        [
                'id' => '',
                'weight' => '',
                'cooldownSeconds' => ''
        ]
    ],
    'fillerRepeatCooldown' => '',
    'groupTitle' => '',
    'guideFlexTitle' => '',
    'guideMinimumDuration' => '',
    'icon' => [
        'path' => '',
        'width' => '',
        'duration' => '',
        'position' => ''
    ],
    'id' => '',
    'name' => '',
    'number' => '',
    'offline' => [
        'picture' => '',
        'soundtrack' => '',
        'mode' => ''
    ],
    'startTime' => '',
    'stealth' => null,
    'transcoding' => [
        'targetResolution' => '',
        'videoBitrate' => '',
        'videoBufferSize' => ''
    ],
    'watermark' => [
        'url' => '',
        'enabled' => null,
        'position' => '',
        'width' => '',
        'verticalMargin' => '',
        'horizontalMargin' => '',
        'duration' => '',
        'fixedSize' => null,
        'animated' => null,
        'opacity' => 0,
        'fadeConfig' => [
                [
                                'programType' => '',
                                'periodMins' => '',
                                'leadingEdge' => null
                ]
        ]
    ],
    'onDemand' => [
        'enabled' => null
    ],
    'streamMode' => '',
    'transcodeConfigId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/channels/:id', [
  'body' => '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/channels/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'disableFillerOverlay' => null,
  'duration' => '',
  'fillerCollections' => [
    [
        'id' => '',
        'weight' => '',
        'cooldownSeconds' => ''
    ]
  ],
  'fillerRepeatCooldown' => '',
  'groupTitle' => '',
  'guideFlexTitle' => '',
  'guideMinimumDuration' => '',
  'icon' => [
    'path' => '',
    'width' => '',
    'duration' => '',
    'position' => ''
  ],
  'id' => '',
  'name' => '',
  'number' => '',
  'offline' => [
    'picture' => '',
    'soundtrack' => '',
    'mode' => ''
  ],
  'startTime' => '',
  'stealth' => null,
  'transcoding' => [
    'targetResolution' => '',
    'videoBitrate' => '',
    'videoBufferSize' => ''
  ],
  'watermark' => [
    'url' => '',
    'enabled' => null,
    'position' => '',
    'width' => '',
    'verticalMargin' => '',
    'horizontalMargin' => '',
    'duration' => '',
    'fixedSize' => null,
    'animated' => null,
    'opacity' => 0,
    'fadeConfig' => [
        [
                'programType' => '',
                'periodMins' => '',
                'leadingEdge' => null
        ]
    ]
  ],
  'onDemand' => [
    'enabled' => null
  ],
  'streamMode' => '',
  'transcodeConfigId' => ''
]));

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

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

append(json_encode([
  'disableFillerOverlay' => null,
  'duration' => '',
  'fillerCollections' => [
    [
        'id' => '',
        'weight' => '',
        'cooldownSeconds' => ''
    ]
  ],
  'fillerRepeatCooldown' => '',
  'groupTitle' => '',
  'guideFlexTitle' => '',
  'guideMinimumDuration' => '',
  'icon' => [
    'path' => '',
    'width' => '',
    'duration' => '',
    'position' => ''
  ],
  'id' => '',
  'name' => '',
  'number' => '',
  'offline' => [
    'picture' => '',
    'soundtrack' => '',
    'mode' => ''
  ],
  'startTime' => '',
  'stealth' => null,
  'transcoding' => [
    'targetResolution' => '',
    'videoBitrate' => '',
    'videoBufferSize' => ''
  ],
  'watermark' => [
    'url' => '',
    'enabled' => null,
    'position' => '',
    'width' => '',
    'verticalMargin' => '',
    'horizontalMargin' => '',
    'duration' => '',
    'fixedSize' => null,
    'animated' => null,
    'opacity' => 0,
    'fadeConfig' => [
        [
                'programType' => '',
                'periodMins' => '',
                'leadingEdge' => null
        ]
    ]
  ],
  'onDemand' => [
    'enabled' => null
  ],
  'streamMode' => '',
  'transcodeConfigId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/channels/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/channels/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/channels/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}'

import http.client

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

payload = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/channels/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/channels/:id"

payload = {
    "disableFillerOverlay": False,
    "duration": "",
    "fillerCollections": [
        {
            "id": "",
            "weight": "",
            "cooldownSeconds": ""
        }
    ],
    "fillerRepeatCooldown": "",
    "groupTitle": "",
    "guideFlexTitle": "",
    "guideMinimumDuration": "",
    "icon": {
        "path": "",
        "width": "",
        "duration": "",
        "position": ""
    },
    "id": "",
    "name": "",
    "number": "",
    "offline": {
        "picture": "",
        "soundtrack": "",
        "mode": ""
    },
    "startTime": "",
    "stealth": False,
    "transcoding": {
        "targetResolution": "",
        "videoBitrate": "",
        "videoBufferSize": ""
    },
    "watermark": {
        "url": "",
        "enabled": False,
        "position": "",
        "width": "",
        "verticalMargin": "",
        "horizontalMargin": "",
        "duration": "",
        "fixedSize": False,
        "animated": False,
        "opacity": 0,
        "fadeConfig": [
            {
                "programType": "",
                "periodMins": "",
                "leadingEdge": False
            }
        ]
    },
    "onDemand": { "enabled": False },
    "streamMode": "",
    "transcodeConfigId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/channels/:id"

payload <- "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/channels/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/channels/:id') do |req|
  req.body = "{\n  \"disableFillerOverlay\": false,\n  \"duration\": \"\",\n  \"fillerCollections\": [\n    {\n      \"id\": \"\",\n      \"weight\": \"\",\n      \"cooldownSeconds\": \"\"\n    }\n  ],\n  \"fillerRepeatCooldown\": \"\",\n  \"groupTitle\": \"\",\n  \"guideFlexTitle\": \"\",\n  \"guideMinimumDuration\": \"\",\n  \"icon\": {\n    \"path\": \"\",\n    \"width\": \"\",\n    \"duration\": \"\",\n    \"position\": \"\"\n  },\n  \"id\": \"\",\n  \"name\": \"\",\n  \"number\": \"\",\n  \"offline\": {\n    \"picture\": \"\",\n    \"soundtrack\": \"\",\n    \"mode\": \"\"\n  },\n  \"startTime\": \"\",\n  \"stealth\": false,\n  \"transcoding\": {\n    \"targetResolution\": \"\",\n    \"videoBitrate\": \"\",\n    \"videoBufferSize\": \"\"\n  },\n  \"watermark\": {\n    \"url\": \"\",\n    \"enabled\": false,\n    \"position\": \"\",\n    \"width\": \"\",\n    \"verticalMargin\": \"\",\n    \"horizontalMargin\": \"\",\n    \"duration\": \"\",\n    \"fixedSize\": false,\n    \"animated\": false,\n    \"opacity\": 0,\n    \"fadeConfig\": [\n      {\n        \"programType\": \"\",\n        \"periodMins\": \"\",\n        \"leadingEdge\": false\n      }\n    ]\n  },\n  \"onDemand\": {\n    \"enabled\": false\n  },\n  \"streamMode\": \"\",\n  \"transcodeConfigId\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "disableFillerOverlay": false,
        "duration": "",
        "fillerCollections": (
            json!({
                "id": "",
                "weight": "",
                "cooldownSeconds": ""
            })
        ),
        "fillerRepeatCooldown": "",
        "groupTitle": "",
        "guideFlexTitle": "",
        "guideMinimumDuration": "",
        "icon": json!({
            "path": "",
            "width": "",
            "duration": "",
            "position": ""
        }),
        "id": "",
        "name": "",
        "number": "",
        "offline": json!({
            "picture": "",
            "soundtrack": "",
            "mode": ""
        }),
        "startTime": "",
        "stealth": false,
        "transcoding": json!({
            "targetResolution": "",
            "videoBitrate": "",
            "videoBufferSize": ""
        }),
        "watermark": json!({
            "url": "",
            "enabled": false,
            "position": "",
            "width": "",
            "verticalMargin": "",
            "horizontalMargin": "",
            "duration": "",
            "fixedSize": false,
            "animated": false,
            "opacity": 0,
            "fadeConfig": (
                json!({
                    "programType": "",
                    "periodMins": "",
                    "leadingEdge": false
                })
            )
        }),
        "onDemand": json!({"enabled": false}),
        "streamMode": "",
        "transcodeConfigId": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    {
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    }
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": {
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  },
  "id": "",
  "name": "",
  "number": "",
  "offline": {
    "picture": "",
    "soundtrack": "",
    "mode": ""
  },
  "startTime": "",
  "stealth": false,
  "transcoding": {
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  },
  "watermark": {
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      {
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      }
    ]
  },
  "onDemand": {
    "enabled": false
  },
  "streamMode": "",
  "transcodeConfigId": ""
}' |  \
  http PUT {{baseUrl}}/api/channels/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "disableFillerOverlay": false,\n  "duration": "",\n  "fillerCollections": [\n    {\n      "id": "",\n      "weight": "",\n      "cooldownSeconds": ""\n    }\n  ],\n  "fillerRepeatCooldown": "",\n  "groupTitle": "",\n  "guideFlexTitle": "",\n  "guideMinimumDuration": "",\n  "icon": {\n    "path": "",\n    "width": "",\n    "duration": "",\n    "position": ""\n  },\n  "id": "",\n  "name": "",\n  "number": "",\n  "offline": {\n    "picture": "",\n    "soundtrack": "",\n    "mode": ""\n  },\n  "startTime": "",\n  "stealth": false,\n  "transcoding": {\n    "targetResolution": "",\n    "videoBitrate": "",\n    "videoBufferSize": ""\n  },\n  "watermark": {\n    "url": "",\n    "enabled": false,\n    "position": "",\n    "width": "",\n    "verticalMargin": "",\n    "horizontalMargin": "",\n    "duration": "",\n    "fixedSize": false,\n    "animated": false,\n    "opacity": 0,\n    "fadeConfig": [\n      {\n        "programType": "",\n        "periodMins": "",\n        "leadingEdge": false\n      }\n    ]\n  },\n  "onDemand": {\n    "enabled": false\n  },\n  "streamMode": "",\n  "transcodeConfigId": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/channels/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "disableFillerOverlay": false,
  "duration": "",
  "fillerCollections": [
    [
      "id": "",
      "weight": "",
      "cooldownSeconds": ""
    ]
  ],
  "fillerRepeatCooldown": "",
  "groupTitle": "",
  "guideFlexTitle": "",
  "guideMinimumDuration": "",
  "icon": [
    "path": "",
    "width": "",
    "duration": "",
    "position": ""
  ],
  "id": "",
  "name": "",
  "number": "",
  "offline": [
    "picture": "",
    "soundtrack": "",
    "mode": ""
  ],
  "startTime": "",
  "stealth": false,
  "transcoding": [
    "targetResolution": "",
    "videoBitrate": "",
    "videoBufferSize": ""
  ],
  "watermark": [
    "url": "",
    "enabled": false,
    "position": "",
    "width": "",
    "verticalMargin": "",
    "horizontalMargin": "",
    "duration": "",
    "fixedSize": false,
    "animated": false,
    "opacity": 0,
    "fadeConfig": [
      [
        "programType": "",
        "periodMins": "",
        "leadingEdge": false
      ]
    ]
  ],
  "onDemand": ["enabled": false],
  "streamMode": "",
  "transcodeConfigId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/custom-shows");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"programs\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/custom-shows" {:content-type :json
                                                             :form-params {:name ""
                                                                           :programs []}})

require "http/client"

url = "{{baseUrl}}/api/custom-shows"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

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}}/api/custom-shows"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"programs\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/custom-shows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"programs\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/custom-shows"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"programs\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/api/custom-shows HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "name": "",
  "programs": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/custom-shows")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/custom-shows"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"programs\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/custom-shows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/custom-shows")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  programs: []
});

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

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

xhr.open('POST', '{{baseUrl}}/api/custom-shows');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/custom-shows',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

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

const url = '{{baseUrl}}/api/custom-shows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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}}/api/custom-shows',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "programs": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/custom-shows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/custom-shows',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({name: '', programs: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/custom-shows',
  headers: {'content-type': 'application/json'},
  body: {name: '', programs: []},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/custom-shows');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  programs: []
});

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}}/api/custom-shows',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

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

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

const url = '{{baseUrl}}/api/custom-shows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"programs": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/custom-shows"]
                                                       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}}/api/custom-shows" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"programs\": []\n}" in

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

 "{{baseUrl}}/api/custom-shows",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'programs' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/custom-shows', [
  'body' => '{
  "name": "",
  "programs": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/custom-shows');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/custom-shows');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/custom-shows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/custom-shows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/custom-shows", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/custom-shows"

payload = {
    "name": "",
    "programs": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/custom-shows"

payload <- "{\n  \"name\": \"\",\n  \"programs\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/custom-shows")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/api/custom-shows') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/custom-shows";

    let payload = json!({
        "name": "",
        "programs": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "name": "",
  "programs": []
}' |  \
  http POST {{baseUrl}}/api/custom-shows \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "programs": []\n}' \
  --output-document \
  - {{baseUrl}}/api/custom-shows

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "programs": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/custom-shows/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/custom-shows/:id")

require "http/client"

url = "{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/custom-shows/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/custom-shows/: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/api/custom-shows/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/custom-shows/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/custom-shows/:id'};

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

const url = '{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/custom-shows/: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/api/custom-shows/: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}}/api/custom-shows/: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}}/api/custom-shows/: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}}/api/custom-shows/:id'};

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

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

const url = '{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/: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}}/api/custom-shows/:id" in

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

 "{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/custom-shows/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/custom-shows/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/custom-shows/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/custom-shows/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/api/custom-shows/:id")

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

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

import requests

url = "{{baseUrl}}/api/custom-shows/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/custom-shows/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/custom-shows/: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/api/custom-shows/: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}}/api/custom-shows/: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);
}

http DELETE {{baseUrl}}/api/custom-shows/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/custom-shows/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/custom-shows/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/custom-shows/:id/programs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/custom-shows/:id/programs")

require "http/client"

url = "{{baseUrl}}/api/custom-shows/:id/programs"

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}}/api/custom-shows/:id/programs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/custom-shows/:id/programs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/custom-shows/:id/programs"

	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/api/custom-shows/:id/programs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/custom-shows/:id/programs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/custom-shows/:id/programs"))
    .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}}/api/custom-shows/:id/programs")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/custom-shows/:id/programs")
  .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}}/api/custom-shows/:id/programs');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/custom-shows/:id/programs'
};

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

const url = '{{baseUrl}}/api/custom-shows/:id/programs';
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}}/api/custom-shows/:id/programs',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/custom-shows/:id/programs")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/custom-shows/:id/programs',
  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}}/api/custom-shows/:id/programs'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/custom-shows/:id/programs');

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}}/api/custom-shows/:id/programs'
};

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

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

const url = '{{baseUrl}}/api/custom-shows/:id/programs';
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}}/api/custom-shows/:id/programs"]
                                                       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}}/api/custom-shows/:id/programs" in

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

 "{{baseUrl}}/api/custom-shows/:id/programs",
  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}}/api/custom-shows/:id/programs');

echo $response->getBody();

setUrl('{{baseUrl}}/api/custom-shows/:id/programs');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/custom-shows/:id/programs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/custom-shows/:id/programs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/custom-shows/:id/programs' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/custom-shows/:id/programs")

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

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

import requests

url = "{{baseUrl}}/api/custom-shows/:id/programs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/custom-shows/:id/programs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/custom-shows/:id/programs")

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/api/custom-shows/:id/programs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/custom-shows/:id/programs";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/custom-shows/:id/programs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/custom-shows/:id/programs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/custom-shows/:id/programs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/custom-shows/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/custom-shows/:id")

require "http/client"

url = "{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/custom-shows/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/custom-shows/: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/api/custom-shows/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/custom-shows/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/custom-shows/:id'};

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

const url = '{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/custom-shows/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/custom-shows/: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}}/api/custom-shows/: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}}/api/custom-shows/: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}}/api/custom-shows/:id'};

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

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

const url = '{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/: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}}/api/custom-shows/:id" in

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

 "{{baseUrl}}/api/custom-shows/: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}}/api/custom-shows/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/custom-shows/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/custom-shows/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/custom-shows/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/custom-shows/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/custom-shows/:id")

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

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

import requests

url = "{{baseUrl}}/api/custom-shows/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/custom-shows/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/custom-shows/: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/api/custom-shows/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/custom-shows/:id";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/custom-shows/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/custom-shows/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/custom-shows/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/custom-shows");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/custom-shows")

require "http/client"

url = "{{baseUrl}}/api/custom-shows"

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}}/api/custom-shows"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/custom-shows");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/custom-shows"

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/custom-shows")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/custom-shows"))
    .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}}/api/custom-shows")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/custom-shows")
  .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}}/api/custom-shows');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/custom-shows'};

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

const url = '{{baseUrl}}/api/custom-shows';
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}}/api/custom-shows',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/custom-shows")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/custom-shows',
  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}}/api/custom-shows'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/custom-shows');

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}}/api/custom-shows'};

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

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

const url = '{{baseUrl}}/api/custom-shows';
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}}/api/custom-shows"]
                                                       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}}/api/custom-shows" in

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

 "{{baseUrl}}/api/custom-shows",
  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}}/api/custom-shows');

echo $response->getBody();

setUrl('{{baseUrl}}/api/custom-shows');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/custom-shows');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/custom-shows' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/custom-shows' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/custom-shows")

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

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

import requests

url = "{{baseUrl}}/api/custom-shows"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/custom-shows"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/custom-shows")

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/api/custom-shows') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/custom-shows";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/custom-shows

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/custom-shows

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/custom-shows")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/custom-shows/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"programs\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/custom-shows/:id" {:content-type :json
                                                                :form-params {:name ""
                                                                              :programs []}})

require "http/client"

url = "{{baseUrl}}/api/custom-shows/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/custom-shows/:id"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"programs\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/custom-shows/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"programs\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/custom-shows/:id"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"programs\": []\n}")

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

	req.Header.Add("content-type", "application/json")

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

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

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

}

PUT /baseUrl/api/custom-shows/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "name": "",
  "programs": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/custom-shows/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/custom-shows/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"programs\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/custom-shows/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/custom-shows/:id")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  programs: []
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/custom-shows/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/custom-shows/:id',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

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

const url = '{{baseUrl}}/api/custom-shows/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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}}/api/custom-shows/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "programs": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/custom-shows/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/custom-shows/:id',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({name: '', programs: []}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/custom-shows/:id',
  headers: {'content-type': 'application/json'},
  body: {name: '', programs: []},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/custom-shows/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  programs: []
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/custom-shows/:id',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

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

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

const url = '{{baseUrl}}/api/custom-shows/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"programs": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/custom-shows/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/api/custom-shows/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"programs\": []\n}" in

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

 "{{baseUrl}}/api/custom-shows/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'programs' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/custom-shows/:id', [
  'body' => '{
  "name": "",
  "programs": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/custom-shows/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/custom-shows/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/custom-shows/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/custom-shows/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/custom-shows/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/custom-shows/:id"

payload = {
    "name": "",
    "programs": []
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/custom-shows/:id"

payload <- "{\n  \"name\": \"\",\n  \"programs\": []\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/custom-shows/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/custom-shows/:id') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/custom-shows/:id";

    let payload = json!({
        "name": "",
        "programs": ()
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "name": "",
  "programs": []
}' |  \
  http PUT {{baseUrl}}/api/custom-shows/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "programs": []\n}' \
  --output-document \
  - {{baseUrl}}/api/custom-shows/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "programs": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/custom-shows/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/channels/reload_all_lineups");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/channels/reload_all_lineups")

require "http/client"

url = "{{baseUrl}}/api/debug/channels/reload_all_lineups"

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}}/api/debug/channels/reload_all_lineups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/channels/reload_all_lineups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/channels/reload_all_lineups"

	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/api/debug/channels/reload_all_lineups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/channels/reload_all_lineups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/channels/reload_all_lineups"))
    .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}}/api/debug/channels/reload_all_lineups")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/channels/reload_all_lineups")
  .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}}/api/debug/channels/reload_all_lineups');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/channels/reload_all_lineups'
};

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

const url = '{{baseUrl}}/api/debug/channels/reload_all_lineups';
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}}/api/debug/channels/reload_all_lineups',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/channels/reload_all_lineups")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/channels/reload_all_lineups',
  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}}/api/debug/channels/reload_all_lineups'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/channels/reload_all_lineups');

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}}/api/debug/channels/reload_all_lineups'
};

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

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

const url = '{{baseUrl}}/api/debug/channels/reload_all_lineups';
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}}/api/debug/channels/reload_all_lineups"]
                                                       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}}/api/debug/channels/reload_all_lineups" in

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

 "{{baseUrl}}/api/debug/channels/reload_all_lineups",
  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}}/api/debug/channels/reload_all_lineups');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/channels/reload_all_lineups');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/channels/reload_all_lineups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/channels/reload_all_lineups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/channels/reload_all_lineups' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/channels/reload_all_lineups")

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

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

import requests

url = "{{baseUrl}}/api/debug/channels/reload_all_lineups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/channels/reload_all_lineups"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/channels/reload_all_lineups")

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/api/debug/channels/reload_all_lineups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/channels/reload_all_lineups";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/channels/reload_all_lineups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/channels/reload_all_lineups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/channels/reload_all_lineups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/db/backup");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/db/backup")

require "http/client"

url = "{{baseUrl}}/api/debug/db/backup"

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}}/api/debug/db/backup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/db/backup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/db/backup"

	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/api/debug/db/backup HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/db/backup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/db/backup"))
    .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}}/api/debug/db/backup")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/db/backup")
  .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}}/api/debug/db/backup');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/debug/db/backup'};

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

const url = '{{baseUrl}}/api/debug/db/backup';
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}}/api/debug/db/backup',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/db/backup")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/db/backup',
  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}}/api/debug/db/backup'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/db/backup');

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}}/api/debug/db/backup'};

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

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

const url = '{{baseUrl}}/api/debug/db/backup';
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}}/api/debug/db/backup"]
                                                       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}}/api/debug/db/backup" in

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

 "{{baseUrl}}/api/debug/db/backup",
  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}}/api/debug/db/backup');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/db/backup');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/db/backup');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/db/backup' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/db/backup' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/db/backup")

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

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

import requests

url = "{{baseUrl}}/api/debug/db/backup"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/db/backup"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/db/backup")

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/api/debug/db/backup') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/db/backup";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/db/backup

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/db/backup

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/db/backup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/db/test_direct_access?id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/db/test_direct_access" {:query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/db/test_direct_access?id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/db/test_direct_access?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/api/debug/db/test_direct_access?id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/db/test_direct_access?id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?id=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/db/test_direct_access',
  params: {id: ''}
};

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

const url = '{{baseUrl}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?id=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/db/test_direct_access?id=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access',
  qs: {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}}/api/debug/db/test_direct_access');

req.query({
  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}}/api/debug/db/test_direct_access',
  params: {id: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?id=" in

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

 "{{baseUrl}}/api/debug/db/test_direct_access?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}}/api/debug/db/test_direct_access?id=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/db/test_direct_access');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/db/test_direct_access');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/db/test_direct_access?id=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/db/test_direct_access?id=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/db/test_direct_access?id=")

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

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

import requests

url = "{{baseUrl}}/api/debug/db/test_direct_access"

querystring = {"id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/db/test_direct_access"

queryString <- list(id = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/db/test_direct_access?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/api/debug/db/test_direct_access') do |req|
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/db/test_direct_access";

    let querystring = [
        ("id", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/db/test_direct_access?id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/db/test_direct_access?id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/db/test_direct_access?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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/ffmpeg/pipeline" {:query-params {:channel ""
                                                                                    :path ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path="

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}}/api/debug/ffmpeg/pipeline?channel=&path="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path="

	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/api/debug/ffmpeg/pipeline?channel=&path= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path="))
    .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}}/api/debug/ffmpeg/pipeline?channel=&path=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=")
  .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}}/api/debug/ffmpeg/pipeline?channel=&path=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/ffmpeg/pipeline',
  params: {channel: '', path: ''}
};

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

const url = '{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=';
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}}/api/debug/ffmpeg/pipeline?channel=&path=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/ffmpeg/pipeline?channel=&path=',
  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}}/api/debug/ffmpeg/pipeline',
  qs: {channel: '', path: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/ffmpeg/pipeline');

req.query({
  channel: '',
  path: ''
});

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}}/api/debug/ffmpeg/pipeline',
  params: {channel: '', path: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=';
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}}/api/debug/ffmpeg/pipeline?channel=&path="]
                                                       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}}/api/debug/ffmpeg/pipeline?channel=&path=" in

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

 "{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=",
  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}}/api/debug/ffmpeg/pipeline?channel=&path=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/ffmpeg/pipeline');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'channel' => '',
  'path' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/ffmpeg/pipeline');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channel' => '',
  'path' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/ffmpeg/pipeline?channel=&path=")

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

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

import requests

url = "{{baseUrl}}/api/debug/ffmpeg/pipeline"

querystring = {"channel":"","path":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/ffmpeg/pipeline"

queryString <- list(
  channel = "",
  path = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=")

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/api/debug/ffmpeg/pipeline') do |req|
  req.params['channel'] = ''
  req.params['path'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/ffmpeg/pipeline";

    let querystring = [
        ("channel", ""),
        ("path", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/ffmpeg/pipeline?channel=&path=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/ffmpeg/probe?path=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/ffmpeg/probe" {:query-params {:path ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/ffmpeg/probe?path="

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}}/api/debug/ffmpeg/probe?path="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/ffmpeg/probe?path=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/ffmpeg/probe?path="

	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/api/debug/ffmpeg/probe?path= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/ffmpeg/probe?path=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/ffmpeg/probe?path="))
    .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}}/api/debug/ffmpeg/probe?path=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/ffmpeg/probe?path=")
  .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}}/api/debug/ffmpeg/probe?path=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/ffmpeg/probe',
  params: {path: ''}
};

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

const url = '{{baseUrl}}/api/debug/ffmpeg/probe?path=';
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}}/api/debug/ffmpeg/probe?path=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/ffmpeg/probe?path=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/ffmpeg/probe?path=',
  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}}/api/debug/ffmpeg/probe',
  qs: {path: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/ffmpeg/probe');

req.query({
  path: ''
});

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}}/api/debug/ffmpeg/probe',
  params: {path: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/ffmpeg/probe?path=';
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}}/api/debug/ffmpeg/probe?path="]
                                                       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}}/api/debug/ffmpeg/probe?path=" in

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

 "{{baseUrl}}/api/debug/ffmpeg/probe?path=",
  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}}/api/debug/ffmpeg/probe?path=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/ffmpeg/probe');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'path' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/ffmpeg/probe');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'path' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/ffmpeg/probe?path=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/ffmpeg/probe?path=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/ffmpeg/probe?path=")

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

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

import requests

url = "{{baseUrl}}/api/debug/ffmpeg/probe"

querystring = {"path":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/ffmpeg/probe"

queryString <- list(path = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/ffmpeg/probe?path=")

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/api/debug/ffmpeg/probe') do |req|
  req.params['path'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/ffmpeg/probe";

    let querystring = [
        ("path", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/ffmpeg/probe?path='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/ffmpeg/probe?path='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/ffmpeg/probe?path=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide" {:query-params {:from ""
                                                                                                     :to ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to="

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}}/api/debug/helpers/channels/:id/build_guide?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to="

	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/api/debug/helpers/channels/:id/build_guide?from=&to= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to="))
    .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}}/api/debug/helpers/channels/:id/build_guide?from=&to=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=")
  .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}}/api/debug/helpers/channels/:id/build_guide?from=&to=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide',
  params: {from: '', to: ''}
};

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

const url = '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=';
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}}/api/debug/helpers/channels/:id/build_guide?from=&to=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/helpers/channels/:id/build_guide?from=&to=',
  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}}/api/debug/helpers/channels/:id/build_guide',
  qs: {from: '', to: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide');

req.query({
  from: '',
  to: ''
});

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}}/api/debug/helpers/channels/:id/build_guide',
  params: {from: '', to: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=';
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}}/api/debug/helpers/channels/:id/build_guide?from=&to="]
                                                       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}}/api/debug/helpers/channels/:id/build_guide?from=&to=" in

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

 "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=",
  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}}/api/debug/helpers/channels/:id/build_guide?from=&to=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/helpers/channels/:id/build_guide');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/helpers/channels/:id/build_guide');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/helpers/channels/:id/build_guide?from=&to=")

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

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

import requests

url = "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide"

queryString <- list(
  from = "",
  to = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=")

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/api/debug/helpers/channels/:id/build_guide') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/helpers/channels/:id/build_guide?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/helpers/create_guide?channelId=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/helpers/create_guide" {:query-params {:channelId ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/helpers/create_guide?channelId="

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}}/api/debug/helpers/create_guide?channelId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/helpers/create_guide?channelId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/helpers/create_guide?channelId="

	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/api/debug/helpers/create_guide?channelId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/helpers/create_guide?channelId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/helpers/create_guide?channelId="))
    .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}}/api/debug/helpers/create_guide?channelId=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/helpers/create_guide?channelId=")
  .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}}/api/debug/helpers/create_guide?channelId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/helpers/create_guide',
  params: {channelId: ''}
};

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

const url = '{{baseUrl}}/api/debug/helpers/create_guide?channelId=';
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}}/api/debug/helpers/create_guide?channelId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/helpers/create_guide?channelId=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/helpers/create_guide?channelId=',
  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}}/api/debug/helpers/create_guide',
  qs: {channelId: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/helpers/create_guide');

req.query({
  channelId: ''
});

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}}/api/debug/helpers/create_guide',
  params: {channelId: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/helpers/create_guide?channelId=';
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}}/api/debug/helpers/create_guide?channelId="]
                                                       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}}/api/debug/helpers/create_guide?channelId=" in

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

 "{{baseUrl}}/api/debug/helpers/create_guide?channelId=",
  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}}/api/debug/helpers/create_guide?channelId=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/helpers/create_guide');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'channelId' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/helpers/create_guide');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channelId' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/helpers/create_guide?channelId=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/helpers/create_guide?channelId=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/helpers/create_guide?channelId=")

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

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

import requests

url = "{{baseUrl}}/api/debug/helpers/create_guide"

querystring = {"channelId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/helpers/create_guide"

queryString <- list(channelId = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/helpers/create_guide?channelId=")

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/api/debug/helpers/create_guide') do |req|
  req.params['channelId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/helpers/create_guide";

    let querystring = [
        ("channelId", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/helpers/create_guide?channelId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/helpers/create_guide?channelId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/helpers/create_guide?channelId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/helpers/current_program?channelId=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/helpers/current_program" {:query-params {:channelId ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/helpers/current_program?channelId="

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}}/api/debug/helpers/current_program?channelId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/helpers/current_program?channelId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/helpers/current_program?channelId="

	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/api/debug/helpers/current_program?channelId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/helpers/current_program?channelId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/helpers/current_program?channelId="))
    .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}}/api/debug/helpers/current_program?channelId=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/helpers/current_program?channelId=")
  .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}}/api/debug/helpers/current_program?channelId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/helpers/current_program',
  params: {channelId: ''}
};

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

const url = '{{baseUrl}}/api/debug/helpers/current_program?channelId=';
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}}/api/debug/helpers/current_program?channelId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/helpers/current_program?channelId=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/helpers/current_program?channelId=',
  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}}/api/debug/helpers/current_program',
  qs: {channelId: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/helpers/current_program');

req.query({
  channelId: ''
});

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}}/api/debug/helpers/current_program',
  params: {channelId: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/helpers/current_program?channelId=';
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}}/api/debug/helpers/current_program?channelId="]
                                                       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}}/api/debug/helpers/current_program?channelId=" in

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

 "{{baseUrl}}/api/debug/helpers/current_program?channelId=",
  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}}/api/debug/helpers/current_program?channelId=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/helpers/current_program');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'channelId' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/helpers/current_program');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channelId' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/helpers/current_program?channelId=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/helpers/current_program?channelId=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/helpers/current_program?channelId=")

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

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

import requests

url = "{{baseUrl}}/api/debug/helpers/current_program"

querystring = {"channelId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/helpers/current_program"

queryString <- list(channelId = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/helpers/current_program?channelId=")

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/api/debug/helpers/current_program') do |req|
  req.params['channelId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/helpers/current_program";

    let querystring = [
        ("channelId", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/helpers/current_program?channelId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/helpers/current_program?channelId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/helpers/current_program?channelId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/helpers/promote_lineup" {:query-params {:channelId ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/helpers/promote_lineup?channelId="

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}}/api/debug/helpers/promote_lineup?channelId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/helpers/promote_lineup?channelId="

	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/api/debug/helpers/promote_lineup?channelId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/helpers/promote_lineup?channelId="))
    .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}}/api/debug/helpers/promote_lineup?channelId=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=")
  .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}}/api/debug/helpers/promote_lineup?channelId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/helpers/promote_lineup',
  params: {channelId: ''}
};

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

const url = '{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=';
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}}/api/debug/helpers/promote_lineup?channelId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/helpers/promote_lineup?channelId=',
  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}}/api/debug/helpers/promote_lineup',
  qs: {channelId: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/helpers/promote_lineup');

req.query({
  channelId: ''
});

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}}/api/debug/helpers/promote_lineup',
  params: {channelId: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=';
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}}/api/debug/helpers/promote_lineup?channelId="]
                                                       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}}/api/debug/helpers/promote_lineup?channelId=" in

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

 "{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=",
  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}}/api/debug/helpers/promote_lineup?channelId=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/helpers/promote_lineup');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'channelId' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/helpers/promote_lineup');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channelId' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/helpers/promote_lineup?channelId=")

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

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

import requests

url = "{{baseUrl}}/api/debug/helpers/promote_lineup"

querystring = {"channelId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/helpers/promote_lineup"

queryString <- list(channelId = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=")

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/api/debug/helpers/promote_lineup') do |req|
  req.params['channelId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/helpers/promote_lineup";

    let querystring = [
        ("channelId", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/helpers/promote_lineup?channelId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/helpers/promote_lineup?channelId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/helpers/promote_lineup?channelId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/helpers/random_filler" {:query-params {:channelId ""
                                                                                          :maxDuration ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration="

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}}/api/debug/helpers/random_filler?channelId=&maxDuration="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration="

	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/api/debug/helpers/random_filler?channelId=&maxDuration= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration="))
    .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}}/api/debug/helpers/random_filler?channelId=&maxDuration=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=")
  .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}}/api/debug/helpers/random_filler?channelId=&maxDuration=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/helpers/random_filler',
  params: {channelId: '', maxDuration: ''}
};

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

const url = '{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=';
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}}/api/debug/helpers/random_filler?channelId=&maxDuration=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/helpers/random_filler?channelId=&maxDuration=',
  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}}/api/debug/helpers/random_filler',
  qs: {channelId: '', maxDuration: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/helpers/random_filler');

req.query({
  channelId: '',
  maxDuration: ''
});

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}}/api/debug/helpers/random_filler',
  params: {channelId: '', maxDuration: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=';
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}}/api/debug/helpers/random_filler?channelId=&maxDuration="]
                                                       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}}/api/debug/helpers/random_filler?channelId=&maxDuration=" in

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

 "{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=",
  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}}/api/debug/helpers/random_filler?channelId=&maxDuration=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/helpers/random_filler');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'channelId' => '',
  'maxDuration' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/helpers/random_filler');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'channelId' => '',
  'maxDuration' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/helpers/random_filler?channelId=&maxDuration=")

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

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

import requests

url = "{{baseUrl}}/api/debug/helpers/random_filler"

querystring = {"channelId":"","maxDuration":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/helpers/random_filler"

queryString <- list(
  channelId = "",
  maxDuration = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=")

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/api/debug/helpers/random_filler') do |req|
  req.params['channelId'] = ''
  req.params['maxDuration'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/helpers/random_filler";

    let querystring = [
        ("channelId", ""),
        ("maxDuration", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/helpers/random_filler?channelId=&maxDuration=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/jellyfin/libraries" {:query-params {:userId ""
                                                                                       :uri ""
                                                                                       :apiKey ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey="

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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey="

	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/api/debug/jellyfin/libraries?userId=&uri=&apiKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey="))
    .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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")
  .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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/jellyfin/libraries',
  params: {userId: '', uri: '', apiKey: ''}
};

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

const url = '{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=';
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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/jellyfin/libraries?userId=&uri=&apiKey=',
  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}}/api/debug/jellyfin/libraries',
  qs: {userId: '', uri: '', apiKey: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/jellyfin/libraries');

req.query({
  userId: '',
  uri: '',
  apiKey: ''
});

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}}/api/debug/jellyfin/libraries',
  params: {userId: '', uri: '', apiKey: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=';
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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey="]
                                                       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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=" in

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

 "{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=",
  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}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/jellyfin/libraries');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'userId' => '',
  'uri' => '',
  'apiKey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/jellyfin/libraries');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'userId' => '',
  'uri' => '',
  'apiKey' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")

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

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

import requests

url = "{{baseUrl}}/api/debug/jellyfin/libraries"

querystring = {"userId":"","uri":"","apiKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/jellyfin/libraries"

queryString <- list(
  userId = "",
  uri = "",
  apiKey = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")

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/api/debug/jellyfin/libraries') do |req|
  req.params['userId'] = ''
  req.params['uri'] = ''
  req.params['apiKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/jellyfin/libraries";

    let querystring = [
        ("userId", ""),
        ("uri", ""),
        ("apiKey", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/jellyfin/libraries?userId=&uri=&apiKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/jellyfin/library/items" {:query-params {:uri ""
                                                                                           :apiKey ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey="

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}}/api/debug/jellyfin/library/items?uri=&apiKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey="

	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/api/debug/jellyfin/library/items?uri=&apiKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey="))
    .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}}/api/debug/jellyfin/library/items?uri=&apiKey=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=")
  .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}}/api/debug/jellyfin/library/items?uri=&apiKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/jellyfin/library/items',
  params: {uri: '', apiKey: ''}
};

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

const url = '{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=';
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}}/api/debug/jellyfin/library/items?uri=&apiKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/jellyfin/library/items?uri=&apiKey=',
  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}}/api/debug/jellyfin/library/items',
  qs: {uri: '', apiKey: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/jellyfin/library/items');

req.query({
  uri: '',
  apiKey: ''
});

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}}/api/debug/jellyfin/library/items',
  params: {uri: '', apiKey: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=';
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}}/api/debug/jellyfin/library/items?uri=&apiKey="]
                                                       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}}/api/debug/jellyfin/library/items?uri=&apiKey=" in

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

 "{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=",
  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}}/api/debug/jellyfin/library/items?uri=&apiKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/jellyfin/library/items');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'uri' => '',
  'apiKey' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/jellyfin/library/items');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'uri' => '',
  'apiKey' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/jellyfin/library/items?uri=&apiKey=")

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

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

import requests

url = "{{baseUrl}}/api/debug/jellyfin/library/items"

querystring = {"uri":"","apiKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/jellyfin/library/items"

queryString <- list(
  uri = "",
  apiKey = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=")

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/api/debug/jellyfin/library/items') do |req|
  req.params['uri'] = ''
  req.params['apiKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/jellyfin/library/items";

    let querystring = [
        ("uri", ""),
        ("apiKey", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/jellyfin/library/items?uri=&apiKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/jellyfin/match_program/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/jellyfin/match_program/:id")

require "http/client"

url = "{{baseUrl}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/jellyfin/match_program/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/jellyfin/match_program/: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/api/debug/jellyfin/match_program/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/jellyfin/match_program/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/jellyfin/match_program/:id'
};

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

const url = '{{baseUrl}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/jellyfin/match_program/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id'
};

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

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

const url = '{{baseUrl}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id" in

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

 "{{baseUrl}}/api/debug/jellyfin/match_program/: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}}/api/debug/jellyfin/match_program/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/jellyfin/match_program/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/jellyfin/match_program/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/jellyfin/match_program/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/jellyfin/match_program/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/jellyfin/match_program/:id")

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

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

import requests

url = "{{baseUrl}}/api/debug/jellyfin/match_program/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/jellyfin/match_program/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/jellyfin/match_program/: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/api/debug/jellyfin/match_program/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/jellyfin/match_program/:id";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/jellyfin/match_program/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/jellyfin/match_program/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/jellyfin/match_program/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/plex/stream_details" {:query-params {:key ""
                                                                                        :mediaSource ""}})

require "http/client"

url = "{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource="

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}}/api/debug/plex/stream_details?key=&mediaSource="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource="

	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/api/debug/plex/stream_details?key=&mediaSource= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource="))
    .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}}/api/debug/plex/stream_details?key=&mediaSource=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=")
  .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}}/api/debug/plex/stream_details?key=&mediaSource=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/plex/stream_details',
  params: {key: '', mediaSource: ''}
};

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

const url = '{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=';
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}}/api/debug/plex/stream_details?key=&mediaSource=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/plex/stream_details?key=&mediaSource=',
  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}}/api/debug/plex/stream_details',
  qs: {key: '', mediaSource: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/plex/stream_details');

req.query({
  key: '',
  mediaSource: ''
});

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}}/api/debug/plex/stream_details',
  params: {key: '', mediaSource: ''}
};

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

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

const url = '{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=';
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}}/api/debug/plex/stream_details?key=&mediaSource="]
                                                       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}}/api/debug/plex/stream_details?key=&mediaSource=" in

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

 "{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=",
  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}}/api/debug/plex/stream_details?key=&mediaSource=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/plex/stream_details');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'key' => '',
  'mediaSource' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/debug/plex/stream_details');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'key' => '',
  'mediaSource' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/plex/stream_details?key=&mediaSource=")

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

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

import requests

url = "{{baseUrl}}/api/debug/plex/stream_details"

querystring = {"key":"","mediaSource":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/plex/stream_details"

queryString <- list(mediaSource = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=")

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/api/debug/plex/stream_details') do |req|
  req.params['key'] = ''
  req.params['mediaSource'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/plex/stream_details";

    let querystring = [
        ("key", ""),
        ("mediaSource", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/plex/stream_details?key=&mediaSource=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/streams/error");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/streams/error")

require "http/client"

url = "{{baseUrl}}/api/debug/streams/error"

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}}/api/debug/streams/error"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/streams/error");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/streams/error"

	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/api/debug/streams/error HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/streams/error")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/streams/error"))
    .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}}/api/debug/streams/error")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/streams/error")
  .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}}/api/debug/streams/error');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/debug/streams/error'};

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

const url = '{{baseUrl}}/api/debug/streams/error';
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}}/api/debug/streams/error',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/streams/error")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/streams/error',
  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}}/api/debug/streams/error'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/streams/error');

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}}/api/debug/streams/error'};

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

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

const url = '{{baseUrl}}/api/debug/streams/error';
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}}/api/debug/streams/error"]
                                                       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}}/api/debug/streams/error" in

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

 "{{baseUrl}}/api/debug/streams/error",
  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}}/api/debug/streams/error');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/streams/error');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/streams/error');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/streams/error' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/streams/error' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/streams/error")

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

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

import requests

url = "{{baseUrl}}/api/debug/streams/error"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/streams/error"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/streams/error")

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/api/debug/streams/error') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/streams/error";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/streams/error

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/streams/error

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/streams/error")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/streams/offline");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/streams/offline")

require "http/client"

url = "{{baseUrl}}/api/debug/streams/offline"

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}}/api/debug/streams/offline"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/streams/offline");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/streams/offline"

	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/api/debug/streams/offline HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/streams/offline")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/streams/offline"))
    .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}}/api/debug/streams/offline")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/streams/offline")
  .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}}/api/debug/streams/offline');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/debug/streams/offline'};

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

const url = '{{baseUrl}}/api/debug/streams/offline';
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}}/api/debug/streams/offline',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/streams/offline")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/streams/offline',
  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}}/api/debug/streams/offline'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/debug/streams/offline');

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}}/api/debug/streams/offline'};

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

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

const url = '{{baseUrl}}/api/debug/streams/offline';
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}}/api/debug/streams/offline"]
                                                       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}}/api/debug/streams/offline" in

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

 "{{baseUrl}}/api/debug/streams/offline",
  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}}/api/debug/streams/offline');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/streams/offline');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/streams/offline');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/streams/offline' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/streams/offline' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/streams/offline")

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

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

import requests

url = "{{baseUrl}}/api/debug/streams/offline"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/streams/offline"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/streams/offline")

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/api/debug/streams/offline') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/streams/offline";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/streams/offline

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/streams/offline

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/streams/offline")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/streams/programs/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/debug/streams/programs/:id")

require "http/client"

url = "{{baseUrl}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/streams/programs/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/streams/programs/: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/api/debug/streams/programs/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/debug/streams/programs/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/debug/streams/programs/:id'
};

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

const url = '{{baseUrl}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/streams/programs/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/streams/programs/: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}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id'
};

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

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

const url = '{{baseUrl}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id" in

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

 "{{baseUrl}}/api/debug/streams/programs/: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}}/api/debug/streams/programs/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/streams/programs/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/debug/streams/programs/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/streams/programs/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/streams/programs/:id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/debug/streams/programs/:id")

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

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

import requests

url = "{{baseUrl}}/api/debug/streams/programs/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/streams/programs/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/streams/programs/: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/api/debug/streams/programs/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/streams/programs/:id";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/debug/streams/programs/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/debug/streams/programs/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/streams/programs/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/guide/debug");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/guide/debug")

require "http/client"

url = "{{baseUrl}}/api/guide/debug"

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}}/api/guide/debug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/guide/debug");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/guide/debug"

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/guide/debug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/guide/debug"))
    .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}}/api/guide/debug")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/guide/debug")
  .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}}/api/guide/debug');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/guide/debug'};

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

const url = '{{baseUrl}}/api/guide/debug';
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}}/api/guide/debug',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/guide/debug")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/guide/debug',
  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}}/api/guide/debug'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/guide/debug');

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}}/api/guide/debug'};

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

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

const url = '{{baseUrl}}/api/guide/debug';
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}}/api/guide/debug"]
                                                       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}}/api/guide/debug" in

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

 "{{baseUrl}}/api/guide/debug",
  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}}/api/guide/debug');

echo $response->getBody();

setUrl('{{baseUrl}}/api/guide/debug');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/guide/debug');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/guide/debug' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/guide/debug' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/guide/debug")

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

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

import requests

url = "{{baseUrl}}/api/guide/debug"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/guide/debug"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/guide/debug")

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/api/guide/debug') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/guide/debug

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/guide/debug

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/guide/debug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/debug/plex/:programId/update_external_ids");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/debug/plex/:programId/update_external_ids")

require "http/client"

url = "{{baseUrl}}/api/debug/plex/:programId/update_external_ids"

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}}/api/debug/plex/:programId/update_external_ids"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/debug/plex/:programId/update_external_ids");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/debug/plex/:programId/update_external_ids"

	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/api/debug/plex/:programId/update_external_ids HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/debug/plex/:programId/update_external_ids")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/debug/plex/:programId/update_external_ids"))
    .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}}/api/debug/plex/:programId/update_external_ids")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/debug/plex/:programId/update_external_ids")
  .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}}/api/debug/plex/:programId/update_external_ids');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/debug/plex/:programId/update_external_ids'
};

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

const url = '{{baseUrl}}/api/debug/plex/:programId/update_external_ids';
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}}/api/debug/plex/:programId/update_external_ids',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/debug/plex/:programId/update_external_ids")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/debug/plex/:programId/update_external_ids',
  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}}/api/debug/plex/:programId/update_external_ids'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/debug/plex/:programId/update_external_ids');

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}}/api/debug/plex/:programId/update_external_ids'
};

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

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

const url = '{{baseUrl}}/api/debug/plex/:programId/update_external_ids';
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}}/api/debug/plex/:programId/update_external_ids"]
                                                       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}}/api/debug/plex/:programId/update_external_ids" in

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

 "{{baseUrl}}/api/debug/plex/:programId/update_external_ids",
  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}}/api/debug/plex/:programId/update_external_ids');

echo $response->getBody();

setUrl('{{baseUrl}}/api/debug/plex/:programId/update_external_ids');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/api/debug/plex/:programId/update_external_ids');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/debug/plex/:programId/update_external_ids' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/debug/plex/:programId/update_external_ids' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/api/debug/plex/:programId/update_external_ids")

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/debug/plex/:programId/update_external_ids"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/debug/plex/:programId/update_external_ids"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/debug/plex/:programId/update_external_ids")

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/api/debug/plex/:programId/update_external_ids') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/debug/plex/:programId/update_external_ids";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/api/debug/plex/:programId/update_external_ids

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/debug/plex/:programId/update_external_ids

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/debug/plex/:programId/update_external_ids")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/filler-lists/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/filler-lists/:id")

require "http/client"

url = "{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/filler-lists/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/filler-lists/: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/api/filler-lists/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/filler-lists/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/filler-lists/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/filler-lists/: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/api/filler-lists/: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}}/api/filler-lists/: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}}/api/filler-lists/: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}}/api/filler-lists/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/: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}}/api/filler-lists/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/filler-lists/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/filler-lists/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/filler-lists/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/filler-lists/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/filler-lists/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/filler-lists/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/filler-lists/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/filler-lists/: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/api/filler-lists/: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}}/api/filler-lists/: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);
}

http DELETE {{baseUrl}}/api/filler-lists/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/filler-lists/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/filler-lists/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/filler-lists/:id/programs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/filler-lists/:id/programs")

require "http/client"

url = "{{baseUrl}}/api/filler-lists/:id/programs"

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}}/api/filler-lists/:id/programs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/filler-lists/:id/programs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/filler-lists/:id/programs"

	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/api/filler-lists/:id/programs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/filler-lists/:id/programs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/filler-lists/:id/programs"))
    .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}}/api/filler-lists/:id/programs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/filler-lists/:id/programs")
  .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}}/api/filler-lists/:id/programs');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/filler-lists/:id/programs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/filler-lists/:id/programs';
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}}/api/filler-lists/:id/programs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/filler-lists/:id/programs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/filler-lists/:id/programs',
  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}}/api/filler-lists/:id/programs'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/filler-lists/:id/programs');

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}}/api/filler-lists/:id/programs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/filler-lists/:id/programs';
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}}/api/filler-lists/:id/programs"]
                                                       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}}/api/filler-lists/:id/programs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/filler-lists/:id/programs",
  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}}/api/filler-lists/:id/programs');

echo $response->getBody();

setUrl('{{baseUrl}}/api/filler-lists/:id/programs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/filler-lists/:id/programs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/filler-lists/:id/programs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/filler-lists/:id/programs' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/filler-lists/:id/programs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/filler-lists/:id/programs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/filler-lists/:id/programs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/filler-lists/:id/programs")

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/api/filler-lists/:id/programs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/filler-lists/:id/programs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/filler-lists/:id/programs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/filler-lists/:id/programs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/filler-lists/:id/programs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/filler-lists/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/filler-lists/:id")

require "http/client"

url = "{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/filler-lists/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/filler-lists/: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/api/filler-lists/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/filler-lists/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/filler-lists/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/filler-lists/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/filler-lists/: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}}/api/filler-lists/: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}}/api/filler-lists/: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}}/api/filler-lists/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/: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}}/api/filler-lists/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/filler-lists/: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}}/api/filler-lists/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/filler-lists/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/filler-lists/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/filler-lists/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/filler-lists/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/filler-lists/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/filler-lists/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/filler-lists/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/filler-lists/: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/api/filler-lists/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/filler-lists/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/filler-lists/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/filler-lists/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/filler-lists/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/filler-lists");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/filler-lists")

require "http/client"

url = "{{baseUrl}}/api/filler-lists"

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}}/api/filler-lists"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/filler-lists");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/filler-lists"

	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/api/filler-lists HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/filler-lists")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/filler-lists"))
    .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}}/api/filler-lists")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/filler-lists")
  .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}}/api/filler-lists');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/filler-lists'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/filler-lists';
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}}/api/filler-lists',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/filler-lists")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/filler-lists',
  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}}/api/filler-lists'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/filler-lists');

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}}/api/filler-lists'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/filler-lists';
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}}/api/filler-lists"]
                                                       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}}/api/filler-lists" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/filler-lists",
  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}}/api/filler-lists');

echo $response->getBody();

setUrl('{{baseUrl}}/api/filler-lists');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/filler-lists');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/filler-lists' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/filler-lists' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/filler-lists")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/filler-lists"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/filler-lists"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/filler-lists")

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/api/filler-lists') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/filler-lists";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/filler-lists

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/filler-lists

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/filler-lists")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/filler-lists");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"programs\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/filler-lists" {:content-type :json
                                                             :form-params {:name ""
                                                                           :programs []}})

require "http/client"

url = "{{baseUrl}}/api/filler-lists"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

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}}/api/filler-lists"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"programs\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/filler-lists");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"programs\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/filler-lists"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"programs\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/filler-lists HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "name": "",
  "programs": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/filler-lists")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/filler-lists"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"programs\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/filler-lists")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/filler-lists")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  programs: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/filler-lists');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/filler-lists',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/filler-lists';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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}}/api/filler-lists',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "programs": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/filler-lists")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/filler-lists',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({name: '', programs: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/filler-lists',
  headers: {'content-type': 'application/json'},
  body: {name: '', programs: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/filler-lists');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  programs: []
});

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}}/api/filler-lists',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/filler-lists';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"programs": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/filler-lists"]
                                                       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}}/api/filler-lists" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"programs\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/filler-lists",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'programs' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/filler-lists', [
  'body' => '{
  "name": "",
  "programs": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/filler-lists');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/filler-lists');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/filler-lists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/filler-lists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/filler-lists", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/filler-lists"

payload = {
    "name": "",
    "programs": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/filler-lists"

payload <- "{\n  \"name\": \"\",\n  \"programs\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/filler-lists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/filler-lists') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/filler-lists";

    let payload = json!({
        "name": "",
        "programs": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "name": "",
  "programs": []
}' |  \
  http POST {{baseUrl}}/api/filler-lists \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "programs": []\n}' \
  --output-document \
  - {{baseUrl}}/api/filler-lists

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "programs": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/filler-lists")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/filler-lists/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"programs\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/filler-lists/:id" {:content-type :json
                                                                :form-params {:name ""
                                                                              :programs []}})

require "http/client"

url = "{{baseUrl}}/api/filler-lists/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/filler-lists/:id"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"programs\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/filler-lists/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"programs\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/filler-lists/:id"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"programs\": []\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/filler-lists/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "name": "",
  "programs": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/filler-lists/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/filler-lists/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"programs\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/filler-lists/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/filler-lists/:id")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"programs\": []\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  programs: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/filler-lists/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/filler-lists/:id',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/filler-lists/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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}}/api/filler-lists/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "programs": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"programs\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/filler-lists/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/filler-lists/:id',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({name: '', programs: []}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/filler-lists/:id',
  headers: {'content-type': 'application/json'},
  body: {name: '', programs: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/filler-lists/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  programs: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/filler-lists/:id',
  headers: {'content-type': 'application/json'},
  data: {name: '', programs: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/filler-lists/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","programs":[]}'
};

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/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"programs": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/filler-lists/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/api/filler-lists/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"programs\": []\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/filler-lists/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'programs' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/filler-lists/:id', [
  'body' => '{
  "name": "",
  "programs": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/filler-lists/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'programs' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/filler-lists/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/filler-lists/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/filler-lists/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "programs": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/filler-lists/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/filler-lists/:id"

payload = {
    "name": "",
    "programs": []
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/filler-lists/:id"

payload <- "{\n  \"name\": \"\",\n  \"programs\": []\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/filler-lists/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/filler-lists/:id') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"programs\": []\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/filler-lists/:id";

    let payload = json!({
        "name": "",
        "programs": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "name": "",
  "programs": []
}' |  \
  http PUT {{baseUrl}}/api/filler-lists/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "programs": []\n}' \
  --output-document \
  - {{baseUrl}}/api/filler-lists/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "programs": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/filler-lists/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/guide/channels/:id" {:query-params {:dateFrom ""
                                                                                 :dateTo ""}})

require "http/client"

url = "{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo="

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}}/api/guide/channels/:id?dateFrom=&dateTo="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo="

	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/api/guide/channels/:id?dateFrom=&dateTo= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo="))
    .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}}/api/guide/channels/:id?dateFrom=&dateTo=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=")
  .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}}/api/guide/channels/:id?dateFrom=&dateTo=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/guide/channels/:id',
  params: {dateFrom: '', dateTo: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=';
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}}/api/guide/channels/:id?dateFrom=&dateTo=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/guide/channels/:id?dateFrom=&dateTo=',
  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}}/api/guide/channels/:id',
  qs: {dateFrom: '', dateTo: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/guide/channels/:id');

req.query({
  dateFrom: '',
  dateTo: ''
});

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}}/api/guide/channels/:id',
  params: {dateFrom: '', dateTo: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=';
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}}/api/guide/channels/:id?dateFrom=&dateTo="]
                                                       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}}/api/guide/channels/:id?dateFrom=&dateTo=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=",
  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}}/api/guide/channels/:id?dateFrom=&dateTo=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/guide/channels/:id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'dateFrom' => '',
  'dateTo' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/guide/channels/:id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'dateFrom' => '',
  'dateTo' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/guide/channels/:id?dateFrom=&dateTo=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/guide/channels/:id"

querystring = {"dateFrom":"","dateTo":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/guide/channels/:id"

queryString <- list(
  dateFrom = "",
  dateTo = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=")

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/api/guide/channels/:id') do |req|
  req.params['dateFrom'] = ''
  req.params['dateTo'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/guide/channels/:id";

    let querystring = [
        ("dateFrom", ""),
        ("dateTo", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/guide/channels/:id?dateFrom=&dateTo=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/guide/channels" {:query-params {:dateFrom ""
                                                                             :dateTo ""}})

require "http/client"

url = "{{baseUrl}}/api/guide/channels?dateFrom=&dateTo="

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}}/api/guide/channels?dateFrom=&dateTo="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/guide/channels?dateFrom=&dateTo="

	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/api/guide/channels?dateFrom=&dateTo= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/guide/channels?dateFrom=&dateTo="))
    .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}}/api/guide/channels?dateFrom=&dateTo=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=")
  .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}}/api/guide/channels?dateFrom=&dateTo=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/guide/channels',
  params: {dateFrom: '', dateTo: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=';
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}}/api/guide/channels?dateFrom=&dateTo=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/guide/channels?dateFrom=&dateTo=',
  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}}/api/guide/channels',
  qs: {dateFrom: '', dateTo: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/guide/channels');

req.query({
  dateFrom: '',
  dateTo: ''
});

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}}/api/guide/channels',
  params: {dateFrom: '', dateTo: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=';
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}}/api/guide/channels?dateFrom=&dateTo="]
                                                       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}}/api/guide/channels?dateFrom=&dateTo=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=",
  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}}/api/guide/channels?dateFrom=&dateTo=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/guide/channels');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'dateFrom' => '',
  'dateTo' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/guide/channels');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'dateFrom' => '',
  'dateTo' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/guide/channels?dateFrom=&dateTo=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/guide/channels"

querystring = {"dateFrom":"","dateTo":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/guide/channels"

queryString <- list(
  dateFrom = "",
  dateTo = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=")

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/api/guide/channels') do |req|
  req.params['dateFrom'] = ''
  req.params['dateTo'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/guide/channels";

    let querystring = [
        ("dateFrom", ""),
        ("dateTo", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/api/guide/channels?dateFrom=&dateTo='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/guide/channels?dateFrom=&dateTo='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/guide/channels?dateFrom=&dateTo=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/guide/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/guide/status")

require "http/client"

url = "{{baseUrl}}/api/guide/status"

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}}/api/guide/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/guide/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/guide/status"

	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/api/guide/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/guide/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/guide/status"))
    .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}}/api/guide/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/guide/status")
  .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}}/api/guide/status');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/guide/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/guide/status';
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}}/api/guide/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/guide/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/guide/status',
  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}}/api/guide/status'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/guide/status');

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}}/api/guide/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/guide/status';
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}}/api/guide/status"]
                                                       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}}/api/guide/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/guide/status",
  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}}/api/guide/status');

echo $response->getBody();

setUrl('{{baseUrl}}/api/guide/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/guide/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/guide/status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/guide/status' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/guide/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/guide/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/guide/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/guide/status")

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/api/guide/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/guide/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/guide/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/guide/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/guide/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/media-sources/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/media-sources/:id")

require "http/client"

url = "{{baseUrl}}/api/media-sources/: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}}/api/media-sources/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/media-sources/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/media-sources/: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/api/media-sources/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/media-sources/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/media-sources/: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}}/api/media-sources/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/media-sources/: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}}/api/media-sources/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/media-sources/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/media-sources/: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}}/api/media-sources/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/media-sources/: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/api/media-sources/: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}}/api/media-sources/: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}}/api/media-sources/: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}}/api/media-sources/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/media-sources/: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}}/api/media-sources/: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}}/api/media-sources/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/media-sources/: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}}/api/media-sources/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/media-sources/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/media-sources/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/media-sources/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/media-sources/:id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/media-sources/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/media-sources/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/media-sources/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/media-sources/: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/api/media-sources/: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}}/api/media-sources/: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);
}

http DELETE {{baseUrl}}/api/media-sources/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/media-sources/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/media-sources/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/media-sources/:id/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/media-sources/:id/status")

require "http/client"

url = "{{baseUrl}}/api/media-sources/:id/status"

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}}/api/media-sources/:id/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/media-sources/:id/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/media-sources/:id/status"

	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/api/media-sources/:id/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/media-sources/:id/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/media-sources/:id/status"))
    .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}}/api/media-sources/:id/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/media-sources/:id/status")
  .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}}/api/media-sources/:id/status');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/media-sources/:id/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/media-sources/:id/status';
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}}/api/media-sources/:id/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/media-sources/:id/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/media-sources/:id/status',
  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}}/api/media-sources/:id/status'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/media-sources/:id/status');

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}}/api/media-sources/:id/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/media-sources/:id/status';
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}}/api/media-sources/:id/status"]
                                                       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}}/api/media-sources/:id/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/media-sources/:id/status",
  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}}/api/media-sources/:id/status');

echo $response->getBody();

setUrl('{{baseUrl}}/api/media-sources/:id/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/media-sources/:id/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/media-sources/:id/status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/media-sources/:id/status' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/media-sources/:id/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/media-sources/:id/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/media-sources/:id/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/media-sources/:id/status")

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/api/media-sources/:id/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/media-sources/:id/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/media-sources/:id/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/media-sources/:id/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/media-sources/:id/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/media-sources");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/media-sources")

require "http/client"

url = "{{baseUrl}}/api/media-sources"

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}}/api/media-sources"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/media-sources");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/media-sources"

	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/api/media-sources HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/media-sources")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/media-sources"))
    .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}}/api/media-sources")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/media-sources")
  .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}}/api/media-sources');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/media-sources'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/media-sources';
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}}/api/media-sources',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/media-sources")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/media-sources',
  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}}/api/media-sources'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/media-sources');

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}}/api/media-sources'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/media-sources';
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}}/api/media-sources"]
                                                       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}}/api/media-sources" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/media-sources",
  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}}/api/media-sources');

echo $response->getBody();

setUrl('{{baseUrl}}/api/media-sources');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/media-sources');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/media-sources' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/media-sources' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/media-sources")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/media-sources"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/media-sources"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/media-sources")

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/api/media-sources') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/media-sources";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/media-sources

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/media-sources

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/media-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/plex/status?serverName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/plex/status" {:query-params {:serverName ""}})

require "http/client"

url = "{{baseUrl}}/api/plex/status?serverName="

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}}/api/plex/status?serverName="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/plex/status?serverName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/plex/status?serverName="

	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/api/plex/status?serverName= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/plex/status?serverName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/plex/status?serverName="))
    .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}}/api/plex/status?serverName=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/plex/status?serverName=")
  .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}}/api/plex/status?serverName=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/plex/status',
  params: {serverName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/plex/status?serverName=';
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}}/api/plex/status?serverName=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/plex/status?serverName=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/plex/status?serverName=',
  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}}/api/plex/status',
  qs: {serverName: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/plex/status');

req.query({
  serverName: ''
});

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}}/api/plex/status',
  params: {serverName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/plex/status?serverName=';
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}}/api/plex/status?serverName="]
                                                       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}}/api/plex/status?serverName=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/plex/status?serverName=",
  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}}/api/plex/status?serverName=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/plex/status');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'serverName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/plex/status');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'serverName' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/plex/status?serverName=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/plex/status?serverName=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/plex/status?serverName=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/plex/status"

querystring = {"serverName":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/plex/status"

queryString <- list(serverName = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/plex/status?serverName=")

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/api/plex/status') do |req|
  req.params['serverName'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/plex/status";

    let querystring = [
        ("serverName", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/api/plex/status?serverName='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/plex/status?serverName='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/plex/status?serverName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/media-sources/foreignstatus");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/media-sources/foreignstatus" {:content-type :json
                                                                            :form-params {:name ""
                                                                                          :accessToken ""
                                                                                          :uri ""
                                                                                          :type ""
                                                                                          :username ""}})

require "http/client"

url = "{{baseUrl}}/api/media-sources/foreignstatus"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}"

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}}/api/media-sources/foreignstatus"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/media-sources/foreignstatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/media-sources/foreignstatus"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/media-sources/foreignstatus HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "name": "",
  "accessToken": "",
  "uri": "",
  "type": "",
  "username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/media-sources/foreignstatus")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/media-sources/foreignstatus"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/media-sources/foreignstatus")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/media-sources/foreignstatus")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  accessToken: '',
  uri: '',
  type: '',
  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}}/api/media-sources/foreignstatus');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/media-sources/foreignstatus',
  headers: {'content-type': 'application/json'},
  data: {name: '', accessToken: '', uri: '', type: '', username: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/media-sources/foreignstatus';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","accessToken":"","uri":"","type":"","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}}/api/media-sources/foreignstatus',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "accessToken": "",\n  "uri": "",\n  "type": "",\n  "username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/media-sources/foreignstatus")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/media-sources/foreignstatus',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({name: '', accessToken: '', uri: '', type: '', username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/media-sources/foreignstatus',
  headers: {'content-type': 'application/json'},
  body: {name: '', accessToken: '', uri: '', type: '', username: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/media-sources/foreignstatus');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  accessToken: '',
  uri: '',
  type: '',
  username: ''
});

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}}/api/media-sources/foreignstatus',
  headers: {'content-type': 'application/json'},
  data: {name: '', accessToken: '', uri: '', type: '', username: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/media-sources/foreignstatus';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","accessToken":"","uri":"","type":"","username":""}'
};

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/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"accessToken": @"",
                              @"uri": @"",
                              @"type": @"",
                              @"username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/media-sources/foreignstatus"]
                                                       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}}/api/media-sources/foreignstatus" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/media-sources/foreignstatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'accessToken' => '',
    'uri' => '',
    'type' => '',
    'username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/media-sources/foreignstatus', [
  'body' => '{
  "name": "",
  "accessToken": "",
  "uri": "",
  "type": "",
  "username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/media-sources/foreignstatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'accessToken' => '',
  'uri' => '',
  'type' => '',
  'username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'accessToken' => '',
  'uri' => '',
  'type' => '',
  'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/media-sources/foreignstatus');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/media-sources/foreignstatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "accessToken": "",
  "uri": "",
  "type": "",
  "username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/media-sources/foreignstatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "accessToken": "",
  "uri": "",
  "type": "",
  "username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/media-sources/foreignstatus", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/media-sources/foreignstatus"

payload = {
    "name": "",
    "accessToken": "",
    "uri": "",
    "type": "",
    "username": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/media-sources/foreignstatus"

payload <- "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/media-sources/foreignstatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/media-sources/foreignstatus') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"accessToken\": \"\",\n  \"uri\": \"\",\n  \"type\": \"\",\n  \"username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/media-sources/foreignstatus";

    let payload = json!({
        "name": "",
        "accessToken": "",
        "uri": "",
        "type": "",
        "username": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "name": "",
  "accessToken": "",
  "uri": "",
  "type": "",
  "username": ""
}' |  \
  http POST {{baseUrl}}/api/media-sources/foreignstatus \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "accessToken": "",\n  "uri": "",\n  "type": "",\n  "username": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/media-sources/foreignstatus

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "accessToken": "",
  "uri": "",
  "type": "",
  "username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/media-sources/foreignstatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/media-sources");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/media-sources")

require "http/client"

url = "{{baseUrl}}/api/media-sources"

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}}/api/media-sources"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/media-sources");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/media-sources"

	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/api/media-sources HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/media-sources")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/media-sources"))
    .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}}/api/media-sources")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/media-sources")
  .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}}/api/media-sources');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/media-sources'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/media-sources';
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}}/api/media-sources',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/media-sources")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/media-sources',
  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}}/api/media-sources'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/media-sources');

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}}/api/media-sources'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/media-sources';
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}}/api/media-sources"]
                                                       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}}/api/media-sources" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/media-sources",
  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}}/api/media-sources');

echo $response->getBody();

setUrl('{{baseUrl}}/api/media-sources');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/media-sources');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/media-sources' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/media-sources' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/media-sources")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/media-sources"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/media-sources"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/media-sources")

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/api/media-sources') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/media-sources";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/api/media-sources

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/media-sources

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/media-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/media-sources/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/media-sources/:id")

require "http/client"

url = "{{baseUrl}}/api/media-sources/:id"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/media-sources/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/media-sources/:id");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/media-sources/:id"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/media-sources/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/media-sources/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/media-sources/:id"))
    .method("PUT", 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}}/api/media-sources/:id")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/media-sources/: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('PUT', '{{baseUrl}}/api/media-sources/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/api/media-sources/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/media-sources/:id';
const options = {method: 'PUT'};

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}}/api/media-sources/:id',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/media-sources/:id")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/media-sources/: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: 'PUT', url: '{{baseUrl}}/api/media-sources/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/media-sources/: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: 'PUT', url: '{{baseUrl}}/api/media-sources/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/media-sources/:id';
const options = {method: 'PUT'};

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}}/api/media-sources/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/api/media-sources/:id" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/media-sources/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/media-sources/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/media-sources/:id');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/media-sources/:id');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/media-sources/:id' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/media-sources/:id' -Method PUT 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/api/media-sources/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/media-sources/:id"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/media-sources/:id"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/media-sources/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/media-sources/: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}}/api/media-sources/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/api/media-sources/:id

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/api/media-sources/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/media-sources/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/programming/batch/lookup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"externalIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/programming/batch/lookup" {:content-type :json
                                                                         :form-params {:externalIds []}})

require "http/client"

url = "{{baseUrl}}/api/programming/batch/lookup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"externalIds\": []\n}"

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}}/api/programming/batch/lookup"),
    Content = new StringContent("{\n  \"externalIds\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/programming/batch/lookup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"externalIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/programming/batch/lookup"

	payload := strings.NewReader("{\n  \"externalIds\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/programming/batch/lookup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "externalIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/programming/batch/lookup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"externalIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/programming/batch/lookup"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"externalIds\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"externalIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/programming/batch/lookup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/programming/batch/lookup")
  .header("content-type", "application/json")
  .body("{\n  \"externalIds\": []\n}")
  .asString();

const data = JSON.stringify({
  externalIds: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/programming/batch/lookup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/programming/batch/lookup',
  headers: {'content-type': 'application/json'},
  data: {externalIds: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/programming/batch/lookup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"externalIds":[]}'
};

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}}/api/programming/batch/lookup',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "externalIds": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"externalIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/programming/batch/lookup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/programming/batch/lookup',
  headers: {
    'content-type': 'application/json'
  }
};

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(JSON.stringify({externalIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/programming/batch/lookup',
  headers: {'content-type': 'application/json'},
  body: {externalIds: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/programming/batch/lookup');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  externalIds: []
});

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}}/api/programming/batch/lookup',
  headers: {'content-type': 'application/json'},
  data: {externalIds: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/programming/batch/lookup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"externalIds":[]}'
};

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/json" };
NSDictionary *parameters = @{ @"externalIds": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/programming/batch/lookup"]
                                                       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}}/api/programming/batch/lookup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"externalIds\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/programming/batch/lookup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'externalIds' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/programming/batch/lookup', [
  'body' => '{
  "externalIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/programming/batch/lookup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'externalIds' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'externalIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/programming/batch/lookup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/programming/batch/lookup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "externalIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/programming/batch/lookup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "externalIds": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"externalIds\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/programming/batch/lookup", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/programming/batch/lookup"

payload = { "externalIds": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/programming/batch/lookup"

payload <- "{\n  \"externalIds\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/programming/batch/lookup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"externalIds\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/programming/batch/lookup') do |req|
  req.body = "{\n  \"externalIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/programming/batch/lookup";

    let payload = json!({"externalIds": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "externalIds": []
}' |  \
  http POST {{baseUrl}}/api/programming/batch/lookup \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "externalIds": []\n}' \
  --output-document \
  - {{baseUrl}}/api/programming/batch/lookup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["externalIds": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/programming/batch/lookup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/programming/seasons/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/programming/seasons/:id")

require "http/client"

url = "{{baseUrl}}/api/programming/seasons/: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}}/api/programming/seasons/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/programming/seasons/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/programming/seasons/: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/api/programming/seasons/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/programming/seasons/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/programming/seasons/: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}}/api/programming/seasons/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/programming/seasons/: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}}/api/programming/seasons/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/programming/seasons/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/programming/seasons/: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}}/api/programming/seasons/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/programming/seasons/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/programming/seasons/: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}}/api/programming/seasons/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});