AWS Elemental MediaLive

POST AcceptInputDeviceTransfer

{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept

QUERY PARAMS

inputDeviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept")

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept"

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

var client = new RestClient("{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept"

	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/prod/inputDevices/:inputDeviceId/accept HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept"))
    .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}}/prod/inputDevices/:inputDeviceId/accept")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept")
  .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}}/prod/inputDevices/:inputDeviceId/accept');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept'
};

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept';
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}}/prod/inputDevices/:inputDeviceId/accept',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDevices/:inputDeviceId/accept',
  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}}/prod/inputDevices/:inputDeviceId/accept'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept');

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}}/prod/inputDevices/:inputDeviceId/accept'
};

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

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept';
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}}/prod/inputDevices/:inputDeviceId/accept"]
                                                       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}}/prod/inputDevices/:inputDeviceId/accept" in

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

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept",
  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}}/prod/inputDevices/:inputDeviceId/accept');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/prod/inputDevices/:inputDeviceId/accept")

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

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

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept")

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/prod/inputDevices/:inputDeviceId/accept') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept";

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId/accept

http POST {{baseUrl}}/prod/inputDevices/:inputDeviceId/accept

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId/accept

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/accept")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST BatchDelete

{{baseUrl}}/prod/batch/delete

BODY json

{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/batch/delete");

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  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/batch/delete" {:content-type :json
                                                              :form-params {:channelIds []
                                                                            :inputIds []
                                                                            :inputSecurityGroupIds []
                                                                            :multiplexIds []}})

require "http/client"

url = "{{baseUrl}}/prod/batch/delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/delete"),
    Content = new StringContent("{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/batch/delete"

	payload := strings.NewReader("{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\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/prod/batch/delete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 93

{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/batch/delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/batch/delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\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  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/batch/delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/batch/delete")
  .header("content-type", "application/json")
  .body("{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}")
  .asString();

const data = JSON.stringify({
  channelIds: [],
  inputIds: [],
  inputSecurityGroupIds: [],
  multiplexIds: []
});

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

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

xhr.open('POST', '{{baseUrl}}/prod/batch/delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/batch/delete',
  headers: {'content-type': 'application/json'},
  data: {channelIds: [], inputIds: [], inputSecurityGroupIds: [], multiplexIds: []}
};

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

const url = '{{baseUrl}}/prod/batch/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIds":[],"inputIds":[],"inputSecurityGroupIds":[],"multiplexIds":[]}'
};

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}}/prod/batch/delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "channelIds": [],\n  "inputIds": [],\n  "inputSecurityGroupIds": [],\n  "multiplexIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/batch/delete")
  .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/prod/batch/delete',
  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({channelIds: [], inputIds: [], inputSecurityGroupIds: [], multiplexIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/batch/delete',
  headers: {'content-type': 'application/json'},
  body: {channelIds: [], inputIds: [], inputSecurityGroupIds: [], multiplexIds: []},
  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}}/prod/batch/delete');

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

req.type('json');
req.send({
  channelIds: [],
  inputIds: [],
  inputSecurityGroupIds: [],
  multiplexIds: []
});

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}}/prod/batch/delete',
  headers: {'content-type': 'application/json'},
  data: {channelIds: [], inputIds: [], inputSecurityGroupIds: [], multiplexIds: []}
};

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

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

const url = '{{baseUrl}}/prod/batch/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIds":[],"inputIds":[],"inputSecurityGroupIds":[],"multiplexIds":[]}'
};

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 = @{ @"channelIds": @[  ],
                              @"inputIds": @[  ],
                              @"inputSecurityGroupIds": @[  ],
                              @"multiplexIds": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/batch/delete"]
                                                       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}}/prod/batch/delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}" in

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

 "{{baseUrl}}/prod/batch/delete",
  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([
    'channelIds' => [
        
    ],
    'inputIds' => [
        
    ],
    'inputSecurityGroupIds' => [
        
    ],
    'multiplexIds' => [
        
    ]
  ]),
  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}}/prod/batch/delete', [
  'body' => '{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/batch/delete');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'channelIds' => [
    
  ],
  'inputIds' => [
    
  ],
  'inputSecurityGroupIds' => [
    
  ],
  'multiplexIds' => [
    
  ]
]));

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

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

append(json_encode([
  'channelIds' => [
    
  ],
  'inputIds' => [
    
  ],
  'inputSecurityGroupIds' => [
    
  ],
  'multiplexIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/batch/delete');
$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}}/prod/batch/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/batch/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}'

import http.client

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

payload = "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}"

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

conn.request("POST", "/baseUrl/prod/batch/delete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/batch/delete"

payload = {
    "channelIds": [],
    "inputIds": [],
    "inputSecurityGroupIds": [],
    "multiplexIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/batch/delete"

payload <- "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/delete")

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  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\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/prod/batch/delete') do |req|
  req.body = "{\n  \"channelIds\": [],\n  \"inputIds\": [],\n  \"inputSecurityGroupIds\": [],\n  \"multiplexIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "channelIds": (),
        "inputIds": (),
        "inputSecurityGroupIds": (),
        "multiplexIds": ()
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/batch/delete \
  --header 'content-type: application/json' \
  --data '{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}'

echo '{
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
}' |  \
  http POST {{baseUrl}}/prod/batch/delete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "channelIds": [],\n  "inputIds": [],\n  "inputSecurityGroupIds": [],\n  "multiplexIds": []\n}' \
  --output-document \
  - {{baseUrl}}/prod/batch/delete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "channelIds": [],
  "inputIds": [],
  "inputSecurityGroupIds": [],
  "multiplexIds": []
] as [String : Any]

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

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

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

dataTask.resume()

POST BatchStart

{{baseUrl}}/prod/batch/start

BODY json

{
  "channelIds": [],
  "multiplexIds": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/batch/start");

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  \"channelIds\": [],\n  \"multiplexIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/batch/start" {:content-type :json
                                                             :form-params {:channelIds []
                                                                           :multiplexIds []}})

require "http/client"

url = "{{baseUrl}}/prod/batch/start"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/start"),
    Content = new StringContent("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/start");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/batch/start"

	payload := strings.NewReader("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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/prod/batch/start HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "channelIds": [],
  "multiplexIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/batch/start")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/batch/start"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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  \"channelIds\": [],\n  \"multiplexIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/batch/start")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/batch/start")
  .header("content-type", "application/json")
  .body("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}")
  .asString();

const data = JSON.stringify({
  channelIds: [],
  multiplexIds: []
});

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

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

xhr.open('POST', '{{baseUrl}}/prod/batch/start');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/batch/start',
  headers: {'content-type': 'application/json'},
  data: {channelIds: [], multiplexIds: []}
};

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

const url = '{{baseUrl}}/prod/batch/start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIds":[],"multiplexIds":[]}'
};

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}}/prod/batch/start',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "channelIds": [],\n  "multiplexIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/batch/start")
  .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/prod/batch/start',
  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({channelIds: [], multiplexIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/batch/start',
  headers: {'content-type': 'application/json'},
  body: {channelIds: [], multiplexIds: []},
  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}}/prod/batch/start');

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

req.type('json');
req.send({
  channelIds: [],
  multiplexIds: []
});

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}}/prod/batch/start',
  headers: {'content-type': 'application/json'},
  data: {channelIds: [], multiplexIds: []}
};

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

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

const url = '{{baseUrl}}/prod/batch/start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIds":[],"multiplexIds":[]}'
};

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 = @{ @"channelIds": @[  ],
                              @"multiplexIds": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/batch/start"]
                                                       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}}/prod/batch/start" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}" in

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

 "{{baseUrl}}/prod/batch/start",
  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([
    'channelIds' => [
        
    ],
    'multiplexIds' => [
        
    ]
  ]),
  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}}/prod/batch/start', [
  'body' => '{
  "channelIds": [],
  "multiplexIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/batch/start');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'channelIds' => [
    
  ],
  'multiplexIds' => [
    
  ]
]));

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

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

append(json_encode([
  'channelIds' => [
    
  ],
  'multiplexIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/batch/start');
$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}}/prod/batch/start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIds": [],
  "multiplexIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/batch/start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIds": [],
  "multiplexIds": []
}'

import http.client

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

payload = "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}"

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

conn.request("POST", "/baseUrl/prod/batch/start", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/batch/start"

payload = {
    "channelIds": [],
    "multiplexIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/batch/start"

payload <- "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/start")

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  \"channelIds\": [],\n  \"multiplexIds\": []\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/prod/batch/start') do |req|
  req.body = "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "channelIds": (),
        "multiplexIds": ()
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/batch/start \
  --header 'content-type: application/json' \
  --data '{
  "channelIds": [],
  "multiplexIds": []
}'

echo '{
  "channelIds": [],
  "multiplexIds": []
}' |  \
  http POST {{baseUrl}}/prod/batch/start \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "channelIds": [],\n  "multiplexIds": []\n}' \
  --output-document \
  - {{baseUrl}}/prod/batch/start

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "channelIds": [],
  "multiplexIds": []
] as [String : Any]

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

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

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

dataTask.resume()

POST BatchStop

{{baseUrl}}/prod/batch/stop

BODY json

{
  "channelIds": [],
  "multiplexIds": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/batch/stop");

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  \"channelIds\": [],\n  \"multiplexIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/batch/stop" {:content-type :json
                                                            :form-params {:channelIds []
                                                                          :multiplexIds []}})

require "http/client"

url = "{{baseUrl}}/prod/batch/stop"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/stop"),
    Content = new StringContent("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/batch/stop"

	payload := strings.NewReader("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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/prod/batch/stop HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "channelIds": [],
  "multiplexIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/batch/stop")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/batch/stop"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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  \"channelIds\": [],\n  \"multiplexIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/batch/stop")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/batch/stop")
  .header("content-type", "application/json")
  .body("{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}")
  .asString();

const data = JSON.stringify({
  channelIds: [],
  multiplexIds: []
});

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

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

xhr.open('POST', '{{baseUrl}}/prod/batch/stop');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/batch/stop',
  headers: {'content-type': 'application/json'},
  data: {channelIds: [], multiplexIds: []}
};

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

const url = '{{baseUrl}}/prod/batch/stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIds":[],"multiplexIds":[]}'
};

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}}/prod/batch/stop',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "channelIds": [],\n  "multiplexIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/batch/stop")
  .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/prod/batch/stop',
  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({channelIds: [], multiplexIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/batch/stop',
  headers: {'content-type': 'application/json'},
  body: {channelIds: [], multiplexIds: []},
  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}}/prod/batch/stop');

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

req.type('json');
req.send({
  channelIds: [],
  multiplexIds: []
});

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}}/prod/batch/stop',
  headers: {'content-type': 'application/json'},
  data: {channelIds: [], multiplexIds: []}
};

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

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

const url = '{{baseUrl}}/prod/batch/stop';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIds":[],"multiplexIds":[]}'
};

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 = @{ @"channelIds": @[  ],
                              @"multiplexIds": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/batch/stop"]
                                                       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}}/prod/batch/stop" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}" in

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

 "{{baseUrl}}/prod/batch/stop",
  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([
    'channelIds' => [
        
    ],
    'multiplexIds' => [
        
    ]
  ]),
  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}}/prod/batch/stop', [
  'body' => '{
  "channelIds": [],
  "multiplexIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/batch/stop');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'channelIds' => [
    
  ],
  'multiplexIds' => [
    
  ]
]));

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

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

append(json_encode([
  'channelIds' => [
    
  ],
  'multiplexIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/batch/stop');
$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}}/prod/batch/stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIds": [],
  "multiplexIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/batch/stop' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIds": [],
  "multiplexIds": []
}'

import http.client

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

payload = "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}"

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

conn.request("POST", "/baseUrl/prod/batch/stop", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/batch/stop"

payload = {
    "channelIds": [],
    "multiplexIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/batch/stop"

payload <- "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\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}}/prod/batch/stop")

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  \"channelIds\": [],\n  \"multiplexIds\": []\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/prod/batch/stop') do |req|
  req.body = "{\n  \"channelIds\": [],\n  \"multiplexIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "channelIds": (),
        "multiplexIds": ()
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/batch/stop \
  --header 'content-type: application/json' \
  --data '{
  "channelIds": [],
  "multiplexIds": []
}'

echo '{
  "channelIds": [],
  "multiplexIds": []
}' |  \
  http POST {{baseUrl}}/prod/batch/stop \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "channelIds": [],\n  "multiplexIds": []\n}' \
  --output-document \
  - {{baseUrl}}/prod/batch/stop

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "channelIds": [],
  "multiplexIds": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/batch/stop")! 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()

PUT BatchUpdateSchedule

{{baseUrl}}/prod/channels/:channelId/schedule

QUERY PARAMS

channelId

BODY json

{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId/schedule");

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  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/prod/channels/:channelId/schedule" {:content-type :json
                                                                             :form-params {:creates {:ScheduleActions ""}
                                                                                           :deletes {:ActionNames ""}}})

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId/schedule"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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}}/prod/channels/:channelId/schedule"),
    Content = new StringContent("{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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}}/prod/channels/:channelId/schedule");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId/schedule"

	payload := strings.NewReader("{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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/prod/channels/:channelId/schedule HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/channels/:channelId/schedule")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels/:channelId/schedule"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/schedule")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/prod/channels/:channelId/schedule")
  .header("content-type", "application/json")
  .body("{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  creates: {
    ScheduleActions: ''
  },
  deletes: {
    ActionNames: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/channels/:channelId/schedule',
  headers: {'content-type': 'application/json'},
  data: {creates: {ScheduleActions: ''}, deletes: {ActionNames: ''}}
};

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

const url = '{{baseUrl}}/prod/channels/:channelId/schedule';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"creates":{"ScheduleActions":""},"deletes":{"ActionNames":""}}'
};

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}}/prod/channels/:channelId/schedule',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "creates": {\n    "ScheduleActions": ""\n  },\n  "deletes": {\n    "ActionNames": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/schedule")
  .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/prod/channels/:channelId/schedule',
  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({creates: {ScheduleActions: ''}, deletes: {ActionNames: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/channels/:channelId/schedule',
  headers: {'content-type': 'application/json'},
  body: {creates: {ScheduleActions: ''}, deletes: {ActionNames: ''}},
  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}}/prod/channels/:channelId/schedule');

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

req.type('json');
req.send({
  creates: {
    ScheduleActions: ''
  },
  deletes: {
    ActionNames: ''
  }
});

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}}/prod/channels/:channelId/schedule',
  headers: {'content-type': 'application/json'},
  data: {creates: {ScheduleActions: ''}, deletes: {ActionNames: ''}}
};

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

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

const url = '{{baseUrl}}/prod/channels/:channelId/schedule';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"creates":{"ScheduleActions":""},"deletes":{"ActionNames":""}}'
};

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 = @{ @"creates": @{ @"ScheduleActions": @"" },
                              @"deletes": @{ @"ActionNames": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/channels/:channelId/schedule"]
                                                       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}}/prod/channels/:channelId/schedule" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/prod/channels/:channelId/schedule",
  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([
    'creates' => [
        'ScheduleActions' => ''
    ],
    'deletes' => [
        'ActionNames' => ''
    ]
  ]),
  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}}/prod/channels/:channelId/schedule', [
  'body' => '{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId/schedule');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'creates' => [
    'ScheduleActions' => ''
  ],
  'deletes' => [
    'ActionNames' => ''
  ]
]));

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

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

append(json_encode([
  'creates' => [
    'ScheduleActions' => ''
  ],
  'deletes' => [
    'ActionNames' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/channels/:channelId/schedule');
$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}}/prod/channels/:channelId/schedule' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId/schedule' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}'

import http.client

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

payload = "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/prod/channels/:channelId/schedule", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/channels/:channelId/schedule"

payload = {
    "creates": { "ScheduleActions": "" },
    "deletes": { "ActionNames": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId/schedule"

payload <- "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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}}/prod/channels/:channelId/schedule")

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  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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/prod/channels/:channelId/schedule') do |req|
  req.body = "{\n  \"creates\": {\n    \"ScheduleActions\": \"\"\n  },\n  \"deletes\": {\n    \"ActionNames\": \"\"\n  }\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}}/prod/channels/:channelId/schedule";

    let payload = json!({
        "creates": json!({"ScheduleActions": ""}),
        "deletes": json!({"ActionNames": ""})
    });

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

curl --request PUT \
  --url {{baseUrl}}/prod/channels/:channelId/schedule \
  --header 'content-type: application/json' \
  --data '{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}'

echo '{
  "creates": {
    "ScheduleActions": ""
  },
  "deletes": {
    "ActionNames": ""
  }
}' |  \
  http PUT {{baseUrl}}/prod/channels/:channelId/schedule \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "creates": {\n    "ScheduleActions": ""\n  },\n  "deletes": {\n    "ActionNames": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId/schedule

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "creates": ["ScheduleActions": ""],
  "deletes": ["ActionNames": ""]
] as [String : Any]

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

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

POST CancelInputDeviceTransfer

{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel

QUERY PARAMS

inputDeviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel")

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel"

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

var client = new RestClient("{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel"

	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/prod/inputDevices/:inputDeviceId/cancel HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel"))
    .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}}/prod/inputDevices/:inputDeviceId/cancel")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel")
  .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}}/prod/inputDevices/:inputDeviceId/cancel');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel'
};

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel';
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}}/prod/inputDevices/:inputDeviceId/cancel',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDevices/:inputDeviceId/cancel',
  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}}/prod/inputDevices/:inputDeviceId/cancel'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel');

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}}/prod/inputDevices/:inputDeviceId/cancel'
};

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

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel';
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}}/prod/inputDevices/:inputDeviceId/cancel"]
                                                       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}}/prod/inputDevices/:inputDeviceId/cancel" in

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

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel",
  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}}/prod/inputDevices/:inputDeviceId/cancel');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/prod/inputDevices/:inputDeviceId/cancel")

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

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

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel")

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/prod/inputDevices/:inputDeviceId/cancel') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel";

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel

http POST {{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST ClaimDevice

{{baseUrl}}/prod/claimDevice

BODY json

{
  "id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/claimDevice");

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  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/claimDevice" {:content-type :json
                                                             :form-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/prod/claimDevice"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\"\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}}/prod/claimDevice"),
    Content = new StringContent("{\n  \"id\": \"\"\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}}/prod/claimDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/claimDevice"

	payload := strings.NewReader("{\n  \"id\": \"\"\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/prod/claimDevice HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 14

{
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/claimDevice")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/claimDevice"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\"\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  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/claimDevice")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/claimDevice")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/claimDevice',
  headers: {'content-type': 'application/json'},
  data: {id: ''}
};

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

const url = '{{baseUrl}}/prod/claimDevice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":""}'
};

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}}/prod/claimDevice',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/claimDevice")
  .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/prod/claimDevice',
  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({id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/claimDevice',
  headers: {'content-type': 'application/json'},
  body: {id: ''},
  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}}/prod/claimDevice');

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

req.type('json');
req.send({
  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: 'POST',
  url: '{{baseUrl}}/prod/claimDevice',
  headers: {'content-type': 'application/json'},
  data: {id: ''}
};

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

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

const url = '{{baseUrl}}/prod/claimDevice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":""}'
};

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 = @{ @"id": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/claimDevice"]
                                                       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}}/prod/claimDevice" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\"\n}" in

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

 "{{baseUrl}}/prod/claimDevice",
  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([
    'id' => ''
  ]),
  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}}/prod/claimDevice', [
  'body' => '{
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/claimDevice');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => ''
]));

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

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

append(json_encode([
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/prod/claimDevice');
$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}}/prod/claimDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/claimDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

import http.client

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

payload = "{\n  \"id\": \"\"\n}"

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

conn.request("POST", "/baseUrl/prod/claimDevice", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/claimDevice"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/claimDevice"

payload <- "{\n  \"id\": \"\"\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}}/prod/claimDevice")

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  \"id\": \"\"\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/prod/claimDevice') do |req|
  req.body = "{\n  \"id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

curl --request POST \
  --url {{baseUrl}}/prod/claimDevice \
  --header 'content-type: application/json' \
  --data '{
  "id": ""
}'

echo '{
  "id": ""
}' |  \
  http POST {{baseUrl}}/prod/claimDevice \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/prod/claimDevice

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["id": ""] as [String : Any]

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

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

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

dataTask.resume()

POST CreateChannel

{{baseUrl}}/prod/channels

BODY json

{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/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  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/channels" {:content-type :json
                                                          :form-params {:cdiInputSpecification {:Resolution ""}
                                                                        :channelClass ""
                                                                        :destinations [{:Id ""
                                                                                        :MediaPackageSettings ""
                                                                                        :MultiplexSettings ""
                                                                                        :Settings ""}]
                                                                        :encoderSettings {:AudioDescriptions ""
                                                                                          :AvailBlanking ""
                                                                                          :AvailConfiguration ""
                                                                                          :BlackoutSlate ""
                                                                                          :CaptionDescriptions ""
                                                                                          :FeatureActivations ""
                                                                                          :GlobalConfiguration ""
                                                                                          :MotionGraphicsConfiguration ""
                                                                                          :NielsenConfiguration ""
                                                                                          :OutputGroups ""
                                                                                          :TimecodeConfig ""
                                                                                          :VideoDescriptions ""}
                                                                        :inputAttachments [{:AutomaticInputFailoverSettings ""
                                                                                            :InputAttachmentName ""
                                                                                            :InputId ""
                                                                                            :InputSettings ""}]
                                                                        :inputSpecification {:Codec ""
                                                                                             :MaximumBitrate ""
                                                                                             :Resolution ""}
                                                                        :logLevel ""
                                                                        :maintenance {:MaintenanceDay ""
                                                                                      :MaintenanceStartTime ""}
                                                                        :name ""
                                                                        :requestId ""
                                                                        :reserved ""
                                                                        :roleArn ""
                                                                        :tags {}
                                                                        :vpc {:PublicAddressAllocationIds ""
                                                                              :SecurityGroupIds ""
                                                                              :SubnetIds ""}}})

require "http/client"

url = "{{baseUrl}}/prod/channels"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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}}/prod/channels"),
    Content = new StringContent("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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}}/prod/channels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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/prod/channels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1139

{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/channels")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/channels")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/channels")
  .header("content-type", "application/json")
  .body("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  cdiInputSpecification: {
    Resolution: ''
  },
  channelClass: '',
  destinations: [
    {
      Id: '',
      MediaPackageSettings: '',
      MultiplexSettings: '',
      Settings: ''
    }
  ],
  encoderSettings: {
    AudioDescriptions: '',
    AvailBlanking: '',
    AvailConfiguration: '',
    BlackoutSlate: '',
    CaptionDescriptions: '',
    FeatureActivations: '',
    GlobalConfiguration: '',
    MotionGraphicsConfiguration: '',
    NielsenConfiguration: '',
    OutputGroups: '',
    TimecodeConfig: '',
    VideoDescriptions: ''
  },
  inputAttachments: [
    {
      AutomaticInputFailoverSettings: '',
      InputAttachmentName: '',
      InputId: '',
      InputSettings: ''
    }
  ],
  inputSpecification: {
    Codec: '',
    MaximumBitrate: '',
    Resolution: ''
  },
  logLevel: '',
  maintenance: {
    MaintenanceDay: '',
    MaintenanceStartTime: ''
  },
  name: '',
  requestId: '',
  reserved: '',
  roleArn: '',
  tags: {},
  vpc: {
    PublicAddressAllocationIds: '',
    SecurityGroupIds: '',
    SubnetIds: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/channels',
  headers: {'content-type': 'application/json'},
  data: {
    cdiInputSpecification: {Resolution: ''},
    channelClass: '',
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
    encoderSettings: {
      AudioDescriptions: '',
      AvailBlanking: '',
      AvailConfiguration: '',
      BlackoutSlate: '',
      CaptionDescriptions: '',
      FeatureActivations: '',
      GlobalConfiguration: '',
      MotionGraphicsConfiguration: '',
      NielsenConfiguration: '',
      OutputGroups: '',
      TimecodeConfig: '',
      VideoDescriptions: ''
    },
    inputAttachments: [
      {
        AutomaticInputFailoverSettings: '',
        InputAttachmentName: '',
        InputId: '',
        InputSettings: ''
      }
    ],
    inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
    logLevel: '',
    maintenance: {MaintenanceDay: '', MaintenanceStartTime: ''},
    name: '',
    requestId: '',
    reserved: '',
    roleArn: '',
    tags: {},
    vpc: {PublicAddressAllocationIds: '', SecurityGroupIds: '', SubnetIds: ''}
  }
};

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

const url = '{{baseUrl}}/prod/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cdiInputSpecification":{"Resolution":""},"channelClass":"","destinations":[{"Id":"","MediaPackageSettings":"","MultiplexSettings":"","Settings":""}],"encoderSettings":{"AudioDescriptions":"","AvailBlanking":"","AvailConfiguration":"","BlackoutSlate":"","CaptionDescriptions":"","FeatureActivations":"","GlobalConfiguration":"","MotionGraphicsConfiguration":"","NielsenConfiguration":"","OutputGroups":"","TimecodeConfig":"","VideoDescriptions":""},"inputAttachments":[{"AutomaticInputFailoverSettings":"","InputAttachmentName":"","InputId":"","InputSettings":""}],"inputSpecification":{"Codec":"","MaximumBitrate":"","Resolution":""},"logLevel":"","maintenance":{"MaintenanceDay":"","MaintenanceStartTime":""},"name":"","requestId":"","reserved":"","roleArn":"","tags":{},"vpc":{"PublicAddressAllocationIds":"","SecurityGroupIds":"","SubnetIds":""}}'
};

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}}/prod/channels',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cdiInputSpecification": {\n    "Resolution": ""\n  },\n  "channelClass": "",\n  "destinations": [\n    {\n      "Id": "",\n      "MediaPackageSettings": "",\n      "MultiplexSettings": "",\n      "Settings": ""\n    }\n  ],\n  "encoderSettings": {\n    "AudioDescriptions": "",\n    "AvailBlanking": "",\n    "AvailConfiguration": "",\n    "BlackoutSlate": "",\n    "CaptionDescriptions": "",\n    "FeatureActivations": "",\n    "GlobalConfiguration": "",\n    "MotionGraphicsConfiguration": "",\n    "NielsenConfiguration": "",\n    "OutputGroups": "",\n    "TimecodeConfig": "",\n    "VideoDescriptions": ""\n  },\n  "inputAttachments": [\n    {\n      "AutomaticInputFailoverSettings": "",\n      "InputAttachmentName": "",\n      "InputId": "",\n      "InputSettings": ""\n    }\n  ],\n  "inputSpecification": {\n    "Codec": "",\n    "MaximumBitrate": "",\n    "Resolution": ""\n  },\n  "logLevel": "",\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceStartTime": ""\n  },\n  "name": "",\n  "requestId": "",\n  "reserved": "",\n  "roleArn": "",\n  "tags": {},\n  "vpc": {\n    "PublicAddressAllocationIds": "",\n    "SecurityGroupIds": "",\n    "SubnetIds": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/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/prod/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({
  cdiInputSpecification: {Resolution: ''},
  channelClass: '',
  destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
  encoderSettings: {
    AudioDescriptions: '',
    AvailBlanking: '',
    AvailConfiguration: '',
    BlackoutSlate: '',
    CaptionDescriptions: '',
    FeatureActivations: '',
    GlobalConfiguration: '',
    MotionGraphicsConfiguration: '',
    NielsenConfiguration: '',
    OutputGroups: '',
    TimecodeConfig: '',
    VideoDescriptions: ''
  },
  inputAttachments: [
    {
      AutomaticInputFailoverSettings: '',
      InputAttachmentName: '',
      InputId: '',
      InputSettings: ''
    }
  ],
  inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
  logLevel: '',
  maintenance: {MaintenanceDay: '', MaintenanceStartTime: ''},
  name: '',
  requestId: '',
  reserved: '',
  roleArn: '',
  tags: {},
  vpc: {PublicAddressAllocationIds: '', SecurityGroupIds: '', SubnetIds: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/channels',
  headers: {'content-type': 'application/json'},
  body: {
    cdiInputSpecification: {Resolution: ''},
    channelClass: '',
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
    encoderSettings: {
      AudioDescriptions: '',
      AvailBlanking: '',
      AvailConfiguration: '',
      BlackoutSlate: '',
      CaptionDescriptions: '',
      FeatureActivations: '',
      GlobalConfiguration: '',
      MotionGraphicsConfiguration: '',
      NielsenConfiguration: '',
      OutputGroups: '',
      TimecodeConfig: '',
      VideoDescriptions: ''
    },
    inputAttachments: [
      {
        AutomaticInputFailoverSettings: '',
        InputAttachmentName: '',
        InputId: '',
        InputSettings: ''
      }
    ],
    inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
    logLevel: '',
    maintenance: {MaintenanceDay: '', MaintenanceStartTime: ''},
    name: '',
    requestId: '',
    reserved: '',
    roleArn: '',
    tags: {},
    vpc: {PublicAddressAllocationIds: '', SecurityGroupIds: '', SubnetIds: ''}
  },
  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}}/prod/channels');

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

req.type('json');
req.send({
  cdiInputSpecification: {
    Resolution: ''
  },
  channelClass: '',
  destinations: [
    {
      Id: '',
      MediaPackageSettings: '',
      MultiplexSettings: '',
      Settings: ''
    }
  ],
  encoderSettings: {
    AudioDescriptions: '',
    AvailBlanking: '',
    AvailConfiguration: '',
    BlackoutSlate: '',
    CaptionDescriptions: '',
    FeatureActivations: '',
    GlobalConfiguration: '',
    MotionGraphicsConfiguration: '',
    NielsenConfiguration: '',
    OutputGroups: '',
    TimecodeConfig: '',
    VideoDescriptions: ''
  },
  inputAttachments: [
    {
      AutomaticInputFailoverSettings: '',
      InputAttachmentName: '',
      InputId: '',
      InputSettings: ''
    }
  ],
  inputSpecification: {
    Codec: '',
    MaximumBitrate: '',
    Resolution: ''
  },
  logLevel: '',
  maintenance: {
    MaintenanceDay: '',
    MaintenanceStartTime: ''
  },
  name: '',
  requestId: '',
  reserved: '',
  roleArn: '',
  tags: {},
  vpc: {
    PublicAddressAllocationIds: '',
    SecurityGroupIds: '',
    SubnetIds: ''
  }
});

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}}/prod/channels',
  headers: {'content-type': 'application/json'},
  data: {
    cdiInputSpecification: {Resolution: ''},
    channelClass: '',
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
    encoderSettings: {
      AudioDescriptions: '',
      AvailBlanking: '',
      AvailConfiguration: '',
      BlackoutSlate: '',
      CaptionDescriptions: '',
      FeatureActivations: '',
      GlobalConfiguration: '',
      MotionGraphicsConfiguration: '',
      NielsenConfiguration: '',
      OutputGroups: '',
      TimecodeConfig: '',
      VideoDescriptions: ''
    },
    inputAttachments: [
      {
        AutomaticInputFailoverSettings: '',
        InputAttachmentName: '',
        InputId: '',
        InputSettings: ''
      }
    ],
    inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
    logLevel: '',
    maintenance: {MaintenanceDay: '', MaintenanceStartTime: ''},
    name: '',
    requestId: '',
    reserved: '',
    roleArn: '',
    tags: {},
    vpc: {PublicAddressAllocationIds: '', SecurityGroupIds: '', SubnetIds: ''}
  }
};

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

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

const url = '{{baseUrl}}/prod/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cdiInputSpecification":{"Resolution":""},"channelClass":"","destinations":[{"Id":"","MediaPackageSettings":"","MultiplexSettings":"","Settings":""}],"encoderSettings":{"AudioDescriptions":"","AvailBlanking":"","AvailConfiguration":"","BlackoutSlate":"","CaptionDescriptions":"","FeatureActivations":"","GlobalConfiguration":"","MotionGraphicsConfiguration":"","NielsenConfiguration":"","OutputGroups":"","TimecodeConfig":"","VideoDescriptions":""},"inputAttachments":[{"AutomaticInputFailoverSettings":"","InputAttachmentName":"","InputId":"","InputSettings":""}],"inputSpecification":{"Codec":"","MaximumBitrate":"","Resolution":""},"logLevel":"","maintenance":{"MaintenanceDay":"","MaintenanceStartTime":""},"name":"","requestId":"","reserved":"","roleArn":"","tags":{},"vpc":{"PublicAddressAllocationIds":"","SecurityGroupIds":"","SubnetIds":""}}'
};

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 = @{ @"cdiInputSpecification": @{ @"Resolution": @"" },
                              @"channelClass": @"",
                              @"destinations": @[ @{ @"Id": @"", @"MediaPackageSettings": @"", @"MultiplexSettings": @"", @"Settings": @"" } ],
                              @"encoderSettings": @{ @"AudioDescriptions": @"", @"AvailBlanking": @"", @"AvailConfiguration": @"", @"BlackoutSlate": @"", @"CaptionDescriptions": @"", @"FeatureActivations": @"", @"GlobalConfiguration": @"", @"MotionGraphicsConfiguration": @"", @"NielsenConfiguration": @"", @"OutputGroups": @"", @"TimecodeConfig": @"", @"VideoDescriptions": @"" },
                              @"inputAttachments": @[ @{ @"AutomaticInputFailoverSettings": @"", @"InputAttachmentName": @"", @"InputId": @"", @"InputSettings": @"" } ],
                              @"inputSpecification": @{ @"Codec": @"", @"MaximumBitrate": @"", @"Resolution": @"" },
                              @"logLevel": @"",
                              @"maintenance": @{ @"MaintenanceDay": @"", @"MaintenanceStartTime": @"" },
                              @"name": @"",
                              @"requestId": @"",
                              @"reserved": @"",
                              @"roleArn": @"",
                              @"tags": @{  },
                              @"vpc": @{ @"PublicAddressAllocationIds": @"", @"SecurityGroupIds": @"", @"SubnetIds": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/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}}/prod/channels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/prod/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([
    'cdiInputSpecification' => [
        'Resolution' => ''
    ],
    'channelClass' => '',
    'destinations' => [
        [
                'Id' => '',
                'MediaPackageSettings' => '',
                'MultiplexSettings' => '',
                'Settings' => ''
        ]
    ],
    'encoderSettings' => [
        'AudioDescriptions' => '',
        'AvailBlanking' => '',
        'AvailConfiguration' => '',
        'BlackoutSlate' => '',
        'CaptionDescriptions' => '',
        'FeatureActivations' => '',
        'GlobalConfiguration' => '',
        'MotionGraphicsConfiguration' => '',
        'NielsenConfiguration' => '',
        'OutputGroups' => '',
        'TimecodeConfig' => '',
        'VideoDescriptions' => ''
    ],
    'inputAttachments' => [
        [
                'AutomaticInputFailoverSettings' => '',
                'InputAttachmentName' => '',
                'InputId' => '',
                'InputSettings' => ''
        ]
    ],
    'inputSpecification' => [
        'Codec' => '',
        'MaximumBitrate' => '',
        'Resolution' => ''
    ],
    'logLevel' => '',
    'maintenance' => [
        'MaintenanceDay' => '',
        'MaintenanceStartTime' => ''
    ],
    'name' => '',
    'requestId' => '',
    'reserved' => '',
    'roleArn' => '',
    'tags' => [
        
    ],
    'vpc' => [
        'PublicAddressAllocationIds' => '',
        'SecurityGroupIds' => '',
        'SubnetIds' => ''
    ]
  ]),
  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}}/prod/channels', [
  'body' => '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cdiInputSpecification' => [
    'Resolution' => ''
  ],
  'channelClass' => '',
  'destinations' => [
    [
        'Id' => '',
        'MediaPackageSettings' => '',
        'MultiplexSettings' => '',
        'Settings' => ''
    ]
  ],
  'encoderSettings' => [
    'AudioDescriptions' => '',
    'AvailBlanking' => '',
    'AvailConfiguration' => '',
    'BlackoutSlate' => '',
    'CaptionDescriptions' => '',
    'FeatureActivations' => '',
    'GlobalConfiguration' => '',
    'MotionGraphicsConfiguration' => '',
    'NielsenConfiguration' => '',
    'OutputGroups' => '',
    'TimecodeConfig' => '',
    'VideoDescriptions' => ''
  ],
  'inputAttachments' => [
    [
        'AutomaticInputFailoverSettings' => '',
        'InputAttachmentName' => '',
        'InputId' => '',
        'InputSettings' => ''
    ]
  ],
  'inputSpecification' => [
    'Codec' => '',
    'MaximumBitrate' => '',
    'Resolution' => ''
  ],
  'logLevel' => '',
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceStartTime' => ''
  ],
  'name' => '',
  'requestId' => '',
  'reserved' => '',
  'roleArn' => '',
  'tags' => [
    
  ],
  'vpc' => [
    'PublicAddressAllocationIds' => '',
    'SecurityGroupIds' => '',
    'SubnetIds' => ''
  ]
]));

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

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

append(json_encode([
  'cdiInputSpecification' => [
    'Resolution' => ''
  ],
  'channelClass' => '',
  'destinations' => [
    [
        'Id' => '',
        'MediaPackageSettings' => '',
        'MultiplexSettings' => '',
        'Settings' => ''
    ]
  ],
  'encoderSettings' => [
    'AudioDescriptions' => '',
    'AvailBlanking' => '',
    'AvailConfiguration' => '',
    'BlackoutSlate' => '',
    'CaptionDescriptions' => '',
    'FeatureActivations' => '',
    'GlobalConfiguration' => '',
    'MotionGraphicsConfiguration' => '',
    'NielsenConfiguration' => '',
    'OutputGroups' => '',
    'TimecodeConfig' => '',
    'VideoDescriptions' => ''
  ],
  'inputAttachments' => [
    [
        'AutomaticInputFailoverSettings' => '',
        'InputAttachmentName' => '',
        'InputId' => '',
        'InputSettings' => ''
    ]
  ],
  'inputSpecification' => [
    'Codec' => '',
    'MaximumBitrate' => '',
    'Resolution' => ''
  ],
  'logLevel' => '',
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceStartTime' => ''
  ],
  'name' => '',
  'requestId' => '',
  'reserved' => '',
  'roleArn' => '',
  'tags' => [
    
  ],
  'vpc' => [
    'PublicAddressAllocationIds' => '',
    'SecurityGroupIds' => '',
    'SubnetIds' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/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}}/prod/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}'

import http.client

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

payload = "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}"

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

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

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

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

import requests

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

payload = {
    "cdiInputSpecification": { "Resolution": "" },
    "channelClass": "",
    "destinations": [
        {
            "Id": "",
            "MediaPackageSettings": "",
            "MultiplexSettings": "",
            "Settings": ""
        }
    ],
    "encoderSettings": {
        "AudioDescriptions": "",
        "AvailBlanking": "",
        "AvailConfiguration": "",
        "BlackoutSlate": "",
        "CaptionDescriptions": "",
        "FeatureActivations": "",
        "GlobalConfiguration": "",
        "MotionGraphicsConfiguration": "",
        "NielsenConfiguration": "",
        "OutputGroups": "",
        "TimecodeConfig": "",
        "VideoDescriptions": ""
    },
    "inputAttachments": [
        {
            "AutomaticInputFailoverSettings": "",
            "InputAttachmentName": "",
            "InputId": "",
            "InputSettings": ""
        }
    ],
    "inputSpecification": {
        "Codec": "",
        "MaximumBitrate": "",
        "Resolution": ""
    },
    "logLevel": "",
    "maintenance": {
        "MaintenanceDay": "",
        "MaintenanceStartTime": ""
    },
    "name": "",
    "requestId": "",
    "reserved": "",
    "roleArn": "",
    "tags": {},
    "vpc": {
        "PublicAddressAllocationIds": "",
        "SecurityGroupIds": "",
        "SubnetIds": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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}}/prod/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  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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/prod/channels') do |req|
  req.body = "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"reserved\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"vpc\": {\n    \"PublicAddressAllocationIds\": \"\",\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "cdiInputSpecification": json!({"Resolution": ""}),
        "channelClass": "",
        "destinations": (
            json!({
                "Id": "",
                "MediaPackageSettings": "",
                "MultiplexSettings": "",
                "Settings": ""
            })
        ),
        "encoderSettings": json!({
            "AudioDescriptions": "",
            "AvailBlanking": "",
            "AvailConfiguration": "",
            "BlackoutSlate": "",
            "CaptionDescriptions": "",
            "FeatureActivations": "",
            "GlobalConfiguration": "",
            "MotionGraphicsConfiguration": "",
            "NielsenConfiguration": "",
            "OutputGroups": "",
            "TimecodeConfig": "",
            "VideoDescriptions": ""
        }),
        "inputAttachments": (
            json!({
                "AutomaticInputFailoverSettings": "",
                "InputAttachmentName": "",
                "InputId": "",
                "InputSettings": ""
            })
        ),
        "inputSpecification": json!({
            "Codec": "",
            "MaximumBitrate": "",
            "Resolution": ""
        }),
        "logLevel": "",
        "maintenance": json!({
            "MaintenanceDay": "",
            "MaintenanceStartTime": ""
        }),
        "name": "",
        "requestId": "",
        "reserved": "",
        "roleArn": "",
        "tags": json!({}),
        "vpc": json!({
            "PublicAddressAllocationIds": "",
            "SecurityGroupIds": "",
            "SubnetIds": ""
        })
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/channels \
  --header 'content-type: application/json' \
  --data '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}'

echo '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": {},
  "vpc": {
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}' |  \
  http POST {{baseUrl}}/prod/channels \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "cdiInputSpecification": {\n    "Resolution": ""\n  },\n  "channelClass": "",\n  "destinations": [\n    {\n      "Id": "",\n      "MediaPackageSettings": "",\n      "MultiplexSettings": "",\n      "Settings": ""\n    }\n  ],\n  "encoderSettings": {\n    "AudioDescriptions": "",\n    "AvailBlanking": "",\n    "AvailConfiguration": "",\n    "BlackoutSlate": "",\n    "CaptionDescriptions": "",\n    "FeatureActivations": "",\n    "GlobalConfiguration": "",\n    "MotionGraphicsConfiguration": "",\n    "NielsenConfiguration": "",\n    "OutputGroups": "",\n    "TimecodeConfig": "",\n    "VideoDescriptions": ""\n  },\n  "inputAttachments": [\n    {\n      "AutomaticInputFailoverSettings": "",\n      "InputAttachmentName": "",\n      "InputId": "",\n      "InputSettings": ""\n    }\n  ],\n  "inputSpecification": {\n    "Codec": "",\n    "MaximumBitrate": "",\n    "Resolution": ""\n  },\n  "logLevel": "",\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceStartTime": ""\n  },\n  "name": "",\n  "requestId": "",\n  "reserved": "",\n  "roleArn": "",\n  "tags": {},\n  "vpc": {\n    "PublicAddressAllocationIds": "",\n    "SecurityGroupIds": "",\n    "SubnetIds": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/prod/channels

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cdiInputSpecification": ["Resolution": ""],
  "channelClass": "",
  "destinations": [
    [
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    ]
  ],
  "encoderSettings": [
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  ],
  "inputAttachments": [
    [
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    ]
  ],
  "inputSpecification": [
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  ],
  "logLevel": "",
  "maintenance": [
    "MaintenanceDay": "",
    "MaintenanceStartTime": ""
  ],
  "name": "",
  "requestId": "",
  "reserved": "",
  "roleArn": "",
  "tags": [],
  "vpc": [
    "PublicAddressAllocationIds": "",
    "SecurityGroupIds": "",
    "SubnetIds": ""
  ]
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateInput

{{baseUrl}}/prod/inputs

BODY json

{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputs");

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  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/inputs" {:content-type :json
                                                        :form-params {:destinations [{:StreamName ""}]
                                                                      :inputDevices [{:Id ""}]
                                                                      :inputSecurityGroups []
                                                                      :mediaConnectFlows [{:FlowArn ""}]
                                                                      :name ""
                                                                      :requestId ""
                                                                      :roleArn ""
                                                                      :sources [{:PasswordParam ""
                                                                                 :Url ""
                                                                                 :Username ""}]
                                                                      :tags {}
                                                                      :type ""
                                                                      :vpc {:SecurityGroupIds ""
                                                                            :SubnetIds ""}}})

require "http/client"

url = "{{baseUrl}}/prod/inputs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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}}/prod/inputs"),
    Content = new StringContent("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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}}/prod/inputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputs"

	payload := strings.NewReader("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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/prod/inputs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 444

{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputs")
  .header("content-type", "application/json")
  .body("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  destinations: [
    {
      StreamName: ''
    }
  ],
  inputDevices: [
    {
      Id: ''
    }
  ],
  inputSecurityGroups: [],
  mediaConnectFlows: [
    {
      FlowArn: ''
    }
  ],
  name: '',
  requestId: '',
  roleArn: '',
  sources: [
    {
      PasswordParam: '',
      Url: '',
      Username: ''
    }
  ],
  tags: {},
  type: '',
  vpc: {
    SecurityGroupIds: '',
    SubnetIds: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputs',
  headers: {'content-type': 'application/json'},
  data: {
    destinations: [{StreamName: ''}],
    inputDevices: [{Id: ''}],
    inputSecurityGroups: [],
    mediaConnectFlows: [{FlowArn: ''}],
    name: '',
    requestId: '',
    roleArn: '',
    sources: [{PasswordParam: '', Url: '', Username: ''}],
    tags: {},
    type: '',
    vpc: {SecurityGroupIds: '', SubnetIds: ''}
  }
};

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

const url = '{{baseUrl}}/prod/inputs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"destinations":[{"StreamName":""}],"inputDevices":[{"Id":""}],"inputSecurityGroups":[],"mediaConnectFlows":[{"FlowArn":""}],"name":"","requestId":"","roleArn":"","sources":[{"PasswordParam":"","Url":"","Username":""}],"tags":{},"type":"","vpc":{"SecurityGroupIds":"","SubnetIds":""}}'
};

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}}/prod/inputs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "destinations": [\n    {\n      "StreamName": ""\n    }\n  ],\n  "inputDevices": [\n    {\n      "Id": ""\n    }\n  ],\n  "inputSecurityGroups": [],\n  "mediaConnectFlows": [\n    {\n      "FlowArn": ""\n    }\n  ],\n  "name": "",\n  "requestId": "",\n  "roleArn": "",\n  "sources": [\n    {\n      "PasswordParam": "",\n      "Url": "",\n      "Username": ""\n    }\n  ],\n  "tags": {},\n  "type": "",\n  "vpc": {\n    "SecurityGroupIds": "",\n    "SubnetIds": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputs")
  .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/prod/inputs',
  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({
  destinations: [{StreamName: ''}],
  inputDevices: [{Id: ''}],
  inputSecurityGroups: [],
  mediaConnectFlows: [{FlowArn: ''}],
  name: '',
  requestId: '',
  roleArn: '',
  sources: [{PasswordParam: '', Url: '', Username: ''}],
  tags: {},
  type: '',
  vpc: {SecurityGroupIds: '', SubnetIds: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputs',
  headers: {'content-type': 'application/json'},
  body: {
    destinations: [{StreamName: ''}],
    inputDevices: [{Id: ''}],
    inputSecurityGroups: [],
    mediaConnectFlows: [{FlowArn: ''}],
    name: '',
    requestId: '',
    roleArn: '',
    sources: [{PasswordParam: '', Url: '', Username: ''}],
    tags: {},
    type: '',
    vpc: {SecurityGroupIds: '', SubnetIds: ''}
  },
  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}}/prod/inputs');

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

req.type('json');
req.send({
  destinations: [
    {
      StreamName: ''
    }
  ],
  inputDevices: [
    {
      Id: ''
    }
  ],
  inputSecurityGroups: [],
  mediaConnectFlows: [
    {
      FlowArn: ''
    }
  ],
  name: '',
  requestId: '',
  roleArn: '',
  sources: [
    {
      PasswordParam: '',
      Url: '',
      Username: ''
    }
  ],
  tags: {},
  type: '',
  vpc: {
    SecurityGroupIds: '',
    SubnetIds: ''
  }
});

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}}/prod/inputs',
  headers: {'content-type': 'application/json'},
  data: {
    destinations: [{StreamName: ''}],
    inputDevices: [{Id: ''}],
    inputSecurityGroups: [],
    mediaConnectFlows: [{FlowArn: ''}],
    name: '',
    requestId: '',
    roleArn: '',
    sources: [{PasswordParam: '', Url: '', Username: ''}],
    tags: {},
    type: '',
    vpc: {SecurityGroupIds: '', SubnetIds: ''}
  }
};

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

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

const url = '{{baseUrl}}/prod/inputs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"destinations":[{"StreamName":""}],"inputDevices":[{"Id":""}],"inputSecurityGroups":[],"mediaConnectFlows":[{"FlowArn":""}],"name":"","requestId":"","roleArn":"","sources":[{"PasswordParam":"","Url":"","Username":""}],"tags":{},"type":"","vpc":{"SecurityGroupIds":"","SubnetIds":""}}'
};

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 = @{ @"destinations": @[ @{ @"StreamName": @"" } ],
                              @"inputDevices": @[ @{ @"Id": @"" } ],
                              @"inputSecurityGroups": @[  ],
                              @"mediaConnectFlows": @[ @{ @"FlowArn": @"" } ],
                              @"name": @"",
                              @"requestId": @"",
                              @"roleArn": @"",
                              @"sources": @[ @{ @"PasswordParam": @"", @"Url": @"", @"Username": @"" } ],
                              @"tags": @{  },
                              @"type": @"",
                              @"vpc": @{ @"SecurityGroupIds": @"", @"SubnetIds": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputs"]
                                                       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}}/prod/inputs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/prod/inputs",
  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([
    'destinations' => [
        [
                'StreamName' => ''
        ]
    ],
    'inputDevices' => [
        [
                'Id' => ''
        ]
    ],
    'inputSecurityGroups' => [
        
    ],
    'mediaConnectFlows' => [
        [
                'FlowArn' => ''
        ]
    ],
    'name' => '',
    'requestId' => '',
    'roleArn' => '',
    'sources' => [
        [
                'PasswordParam' => '',
                'Url' => '',
                'Username' => ''
        ]
    ],
    'tags' => [
        
    ],
    'type' => '',
    'vpc' => [
        'SecurityGroupIds' => '',
        'SubnetIds' => ''
    ]
  ]),
  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}}/prod/inputs', [
  'body' => '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'destinations' => [
    [
        'StreamName' => ''
    ]
  ],
  'inputDevices' => [
    [
        'Id' => ''
    ]
  ],
  'inputSecurityGroups' => [
    
  ],
  'mediaConnectFlows' => [
    [
        'FlowArn' => ''
    ]
  ],
  'name' => '',
  'requestId' => '',
  'roleArn' => '',
  'sources' => [
    [
        'PasswordParam' => '',
        'Url' => '',
        'Username' => ''
    ]
  ],
  'tags' => [
    
  ],
  'type' => '',
  'vpc' => [
    'SecurityGroupIds' => '',
    'SubnetIds' => ''
  ]
]));

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

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

append(json_encode([
  'destinations' => [
    [
        'StreamName' => ''
    ]
  ],
  'inputDevices' => [
    [
        'Id' => ''
    ]
  ],
  'inputSecurityGroups' => [
    
  ],
  'mediaConnectFlows' => [
    [
        'FlowArn' => ''
    ]
  ],
  'name' => '',
  'requestId' => '',
  'roleArn' => '',
  'sources' => [
    [
        'PasswordParam' => '',
        'Url' => '',
        'Username' => ''
    ]
  ],
  'tags' => [
    
  ],
  'type' => '',
  'vpc' => [
    'SecurityGroupIds' => '',
    'SubnetIds' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputs');
$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}}/prod/inputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}'

import http.client

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

payload = "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/prod/inputs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/inputs"

payload = {
    "destinations": [{ "StreamName": "" }],
    "inputDevices": [{ "Id": "" }],
    "inputSecurityGroups": [],
    "mediaConnectFlows": [{ "FlowArn": "" }],
    "name": "",
    "requestId": "",
    "roleArn": "",
    "sources": [
        {
            "PasswordParam": "",
            "Url": "",
            "Username": ""
        }
    ],
    "tags": {},
    "type": "",
    "vpc": {
        "SecurityGroupIds": "",
        "SubnetIds": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputs"

payload <- "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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}}/prod/inputs")

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  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\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/prod/inputs') do |req|
  req.body = "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"type\": \"\",\n  \"vpc\": {\n    \"SecurityGroupIds\": \"\",\n    \"SubnetIds\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "destinations": (json!({"StreamName": ""})),
        "inputDevices": (json!({"Id": ""})),
        "inputSecurityGroups": (),
        "mediaConnectFlows": (json!({"FlowArn": ""})),
        "name": "",
        "requestId": "",
        "roleArn": "",
        "sources": (
            json!({
                "PasswordParam": "",
                "Url": "",
                "Username": ""
            })
        ),
        "tags": json!({}),
        "type": "",
        "vpc": json!({
            "SecurityGroupIds": "",
            "SubnetIds": ""
        })
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/inputs \
  --header 'content-type: application/json' \
  --data '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}'

echo '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ],
  "tags": {},
  "type": "",
  "vpc": {
    "SecurityGroupIds": "",
    "SubnetIds": ""
  }
}' |  \
  http POST {{baseUrl}}/prod/inputs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "destinations": [\n    {\n      "StreamName": ""\n    }\n  ],\n  "inputDevices": [\n    {\n      "Id": ""\n    }\n  ],\n  "inputSecurityGroups": [],\n  "mediaConnectFlows": [\n    {\n      "FlowArn": ""\n    }\n  ],\n  "name": "",\n  "requestId": "",\n  "roleArn": "",\n  "sources": [\n    {\n      "PasswordParam": "",\n      "Url": "",\n      "Username": ""\n    }\n  ],\n  "tags": {},\n  "type": "",\n  "vpc": {\n    "SecurityGroupIds": "",\n    "SubnetIds": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "destinations": [["StreamName": ""]],
  "inputDevices": [["Id": ""]],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [["FlowArn": ""]],
  "name": "",
  "requestId": "",
  "roleArn": "",
  "sources": [
    [
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    ]
  ],
  "tags": [],
  "type": "",
  "vpc": [
    "SecurityGroupIds": "",
    "SubnetIds": ""
  ]
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateInputSecurityGroup

{{baseUrl}}/prod/inputSecurityGroups

BODY json

{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputSecurityGroups");

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  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/inputSecurityGroups" {:content-type :json
                                                                     :form-params {:tags {}
                                                                                   :whitelistRules [{:Cidr ""}]}})

require "http/client"

url = "{{baseUrl}}/prod/inputSecurityGroups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups"),
    Content = new StringContent("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputSecurityGroups"

	payload := strings.NewReader("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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/prod/inputSecurityGroups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputSecurityGroups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputSecurityGroups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputSecurityGroups")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  tags: {},
  whitelistRules: [
    {
      Cidr: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputSecurityGroups',
  headers: {'content-type': 'application/json'},
  data: {tags: {}, whitelistRules: [{Cidr: ''}]}
};

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

const url = '{{baseUrl}}/prod/inputSecurityGroups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{},"whitelistRules":[{"Cidr":""}]}'
};

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}}/prod/inputSecurityGroups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {},\n  "whitelistRules": [\n    {\n      "Cidr": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups")
  .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/prod/inputSecurityGroups',
  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({tags: {}, whitelistRules: [{Cidr: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputSecurityGroups',
  headers: {'content-type': 'application/json'},
  body: {tags: {}, whitelistRules: [{Cidr: ''}]},
  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}}/prod/inputSecurityGroups');

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

req.type('json');
req.send({
  tags: {},
  whitelistRules: [
    {
      Cidr: ''
    }
  ]
});

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}}/prod/inputSecurityGroups',
  headers: {'content-type': 'application/json'},
  data: {tags: {}, whitelistRules: [{Cidr: ''}]}
};

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

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

const url = '{{baseUrl}}/prod/inputSecurityGroups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{},"whitelistRules":[{"Cidr":""}]}'
};

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 = @{ @"tags": @{  },
                              @"whitelistRules": @[ @{ @"Cidr": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputSecurityGroups"]
                                                       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}}/prod/inputSecurityGroups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/prod/inputSecurityGroups",
  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([
    'tags' => [
        
    ],
    'whitelistRules' => [
        [
                'Cidr' => ''
        ]
    ]
  ]),
  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}}/prod/inputSecurityGroups', [
  'body' => '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputSecurityGroups');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ],
  'whitelistRules' => [
    [
        'Cidr' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'tags' => [
    
  ],
  'whitelistRules' => [
    [
        'Cidr' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputSecurityGroups');
$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}}/prod/inputSecurityGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputSecurityGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/prod/inputSecurityGroups", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/inputSecurityGroups"

payload = {
    "tags": {},
    "whitelistRules": [{ "Cidr": "" }]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputSecurityGroups"

payload <- "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups")

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  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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/prod/inputSecurityGroups') do |req|
  req.body = "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "tags": json!({}),
        "whitelistRules": (json!({"Cidr": ""}))
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/inputSecurityGroups \
  --header 'content-type: application/json' \
  --data '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}'

echo '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/prod/inputSecurityGroups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {},\n  "whitelistRules": [\n    {\n      "Cidr": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputSecurityGroups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "tags": [],
  "whitelistRules": [["Cidr": ""]]
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateMultiplex

{{baseUrl}}/prod/multiplexes

BODY json

{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes");

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  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/multiplexes" {:content-type :json
                                                             :form-params {:availabilityZones []
                                                                           :multiplexSettings {:MaximumVideoBufferDelayMilliseconds ""
                                                                                               :TransportStreamBitrate ""
                                                                                               :TransportStreamId ""
                                                                                               :TransportStreamReservedBitrate ""}
                                                                           :name ""
                                                                           :requestId ""
                                                                           :tags {}}})

require "http/client"

url = "{{baseUrl}}/prod/multiplexes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\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}}/prod/multiplexes"),
    Content = new StringContent("{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\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}}/prod/multiplexes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/multiplexes"

	payload := strings.NewReader("{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\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/prod/multiplexes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 257

{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/multiplexes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\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  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/multiplexes")
  .header("content-type", "application/json")
  .body("{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  availabilityZones: [],
  multiplexSettings: {
    MaximumVideoBufferDelayMilliseconds: '',
    TransportStreamBitrate: '',
    TransportStreamId: '',
    TransportStreamReservedBitrate: ''
  },
  name: '',
  requestId: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/multiplexes',
  headers: {'content-type': 'application/json'},
  data: {
    availabilityZones: [],
    multiplexSettings: {
      MaximumVideoBufferDelayMilliseconds: '',
      TransportStreamBitrate: '',
      TransportStreamId: '',
      TransportStreamReservedBitrate: ''
    },
    name: '',
    requestId: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/prod/multiplexes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"availabilityZones":[],"multiplexSettings":{"MaximumVideoBufferDelayMilliseconds":"","TransportStreamBitrate":"","TransportStreamId":"","TransportStreamReservedBitrate":""},"name":"","requestId":"","tags":{}}'
};

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}}/prod/multiplexes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "availabilityZones": [],\n  "multiplexSettings": {\n    "MaximumVideoBufferDelayMilliseconds": "",\n    "TransportStreamBitrate": "",\n    "TransportStreamId": "",\n    "TransportStreamReservedBitrate": ""\n  },\n  "name": "",\n  "requestId": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes")
  .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/prod/multiplexes',
  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({
  availabilityZones: [],
  multiplexSettings: {
    MaximumVideoBufferDelayMilliseconds: '',
    TransportStreamBitrate: '',
    TransportStreamId: '',
    TransportStreamReservedBitrate: ''
  },
  name: '',
  requestId: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/multiplexes',
  headers: {'content-type': 'application/json'},
  body: {
    availabilityZones: [],
    multiplexSettings: {
      MaximumVideoBufferDelayMilliseconds: '',
      TransportStreamBitrate: '',
      TransportStreamId: '',
      TransportStreamReservedBitrate: ''
    },
    name: '',
    requestId: '',
    tags: {}
  },
  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}}/prod/multiplexes');

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

req.type('json');
req.send({
  availabilityZones: [],
  multiplexSettings: {
    MaximumVideoBufferDelayMilliseconds: '',
    TransportStreamBitrate: '',
    TransportStreamId: '',
    TransportStreamReservedBitrate: ''
  },
  name: '',
  requestId: '',
  tags: {}
});

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}}/prod/multiplexes',
  headers: {'content-type': 'application/json'},
  data: {
    availabilityZones: [],
    multiplexSettings: {
      MaximumVideoBufferDelayMilliseconds: '',
      TransportStreamBitrate: '',
      TransportStreamId: '',
      TransportStreamReservedBitrate: ''
    },
    name: '',
    requestId: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/prod/multiplexes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"availabilityZones":[],"multiplexSettings":{"MaximumVideoBufferDelayMilliseconds":"","TransportStreamBitrate":"","TransportStreamId":"","TransportStreamReservedBitrate":""},"name":"","requestId":"","tags":{}}'
};

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 = @{ @"availabilityZones": @[  ],
                              @"multiplexSettings": @{ @"MaximumVideoBufferDelayMilliseconds": @"", @"TransportStreamBitrate": @"", @"TransportStreamId": @"", @"TransportStreamReservedBitrate": @"" },
                              @"name": @"",
                              @"requestId": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/multiplexes"]
                                                       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}}/prod/multiplexes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/prod/multiplexes",
  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([
    'availabilityZones' => [
        
    ],
    'multiplexSettings' => [
        'MaximumVideoBufferDelayMilliseconds' => '',
        'TransportStreamBitrate' => '',
        'TransportStreamId' => '',
        'TransportStreamReservedBitrate' => ''
    ],
    'name' => '',
    'requestId' => '',
    'tags' => [
        
    ]
  ]),
  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}}/prod/multiplexes', [
  'body' => '{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'availabilityZones' => [
    
  ],
  'multiplexSettings' => [
    'MaximumVideoBufferDelayMilliseconds' => '',
    'TransportStreamBitrate' => '',
    'TransportStreamId' => '',
    'TransportStreamReservedBitrate' => ''
  ],
  'name' => '',
  'requestId' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'availabilityZones' => [
    
  ],
  'multiplexSettings' => [
    'MaximumVideoBufferDelayMilliseconds' => '',
    'TransportStreamBitrate' => '',
    'TransportStreamId' => '',
    'TransportStreamReservedBitrate' => ''
  ],
  'name' => '',
  'requestId' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/multiplexes');
$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}}/prod/multiplexes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/prod/multiplexes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/multiplexes"

payload = {
    "availabilityZones": [],
    "multiplexSettings": {
        "MaximumVideoBufferDelayMilliseconds": "",
        "TransportStreamBitrate": "",
        "TransportStreamId": "",
        "TransportStreamReservedBitrate": ""
    },
    "name": "",
    "requestId": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes"

payload <- "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\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}}/prod/multiplexes")

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  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\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/prod/multiplexes') do |req|
  req.body = "{\n  \"availabilityZones\": [],\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\",\n  \"requestId\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "availabilityZones": (),
        "multiplexSettings": json!({
            "MaximumVideoBufferDelayMilliseconds": "",
            "TransportStreamBitrate": "",
            "TransportStreamId": "",
            "TransportStreamReservedBitrate": ""
        }),
        "name": "",
        "requestId": "",
        "tags": json!({})
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/multiplexes \
  --header 'content-type: application/json' \
  --data '{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}'

echo '{
  "availabilityZones": [],
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": "",
  "requestId": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/prod/multiplexes \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "availabilityZones": [],\n  "multiplexSettings": {\n    "MaximumVideoBufferDelayMilliseconds": "",\n    "TransportStreamBitrate": "",\n    "TransportStreamId": "",\n    "TransportStreamReservedBitrate": ""\n  },\n  "name": "",\n  "requestId": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/prod/multiplexes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "availabilityZones": [],
  "multiplexSettings": [
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  ],
  "name": "",
  "requestId": "",
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateMultiplexProgram

{{baseUrl}}/prod/multiplexes/:multiplexId/programs

QUERY PARAMS

multiplexId

BODY json

{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/programs");

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  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/multiplexes/:multiplexId/programs" {:content-type :json
                                                                                   :form-params {:multiplexProgramSettings {:PreferredChannelPipeline ""
                                                                                                                            :ProgramNumber ""
                                                                                                                            :ServiceDescriptor ""
                                                                                                                            :VideoSettings ""}
                                                                                                 :programName ""
                                                                                                 :requestId ""}})

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\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}}/prod/multiplexes/:multiplexId/programs"),
    Content = new StringContent("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\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}}/prod/multiplexes/:multiplexId/programs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/programs"

	payload := strings.NewReader("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\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/prod/multiplexes/:multiplexId/programs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 193

{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/multiplexes/:multiplexId/programs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId/programs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\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  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/multiplexes/:multiplexId/programs")
  .header("content-type", "application/json")
  .body("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  multiplexProgramSettings: {
    PreferredChannelPipeline: '',
    ProgramNumber: '',
    ServiceDescriptor: '',
    VideoSettings: ''
  },
  programName: '',
  requestId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/prod/multiplexes/:multiplexId/programs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs',
  headers: {'content-type': 'application/json'},
  data: {
    multiplexProgramSettings: {
      PreferredChannelPipeline: '',
      ProgramNumber: '',
      ServiceDescriptor: '',
      VideoSettings: ''
    },
    programName: '',
    requestId: ''
  }
};

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"multiplexProgramSettings":{"PreferredChannelPipeline":"","ProgramNumber":"","ServiceDescriptor":"","VideoSettings":""},"programName":"","requestId":""}'
};

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}}/prod/multiplexes/:multiplexId/programs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "multiplexProgramSettings": {\n    "PreferredChannelPipeline": "",\n    "ProgramNumber": "",\n    "ServiceDescriptor": "",\n    "VideoSettings": ""\n  },\n  "programName": "",\n  "requestId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs")
  .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/prod/multiplexes/:multiplexId/programs',
  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({
  multiplexProgramSettings: {
    PreferredChannelPipeline: '',
    ProgramNumber: '',
    ServiceDescriptor: '',
    VideoSettings: ''
  },
  programName: '',
  requestId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs',
  headers: {'content-type': 'application/json'},
  body: {
    multiplexProgramSettings: {
      PreferredChannelPipeline: '',
      ProgramNumber: '',
      ServiceDescriptor: '',
      VideoSettings: ''
    },
    programName: '',
    requestId: ''
  },
  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}}/prod/multiplexes/:multiplexId/programs');

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

req.type('json');
req.send({
  multiplexProgramSettings: {
    PreferredChannelPipeline: '',
    ProgramNumber: '',
    ServiceDescriptor: '',
    VideoSettings: ''
  },
  programName: '',
  requestId: ''
});

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}}/prod/multiplexes/:multiplexId/programs',
  headers: {'content-type': 'application/json'},
  data: {
    multiplexProgramSettings: {
      PreferredChannelPipeline: '',
      ProgramNumber: '',
      ServiceDescriptor: '',
      VideoSettings: ''
    },
    programName: '',
    requestId: ''
  }
};

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

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"multiplexProgramSettings":{"PreferredChannelPipeline":"","ProgramNumber":"","ServiceDescriptor":"","VideoSettings":""},"programName":"","requestId":""}'
};

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 = @{ @"multiplexProgramSettings": @{ @"PreferredChannelPipeline": @"", @"ProgramNumber": @"", @"ServiceDescriptor": @"", @"VideoSettings": @"" },
                              @"programName": @"",
                              @"requestId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/multiplexes/:multiplexId/programs"]
                                                       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}}/prod/multiplexes/:multiplexId/programs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}" in

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

 "{{baseUrl}}/prod/multiplexes/:multiplexId/programs",
  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([
    'multiplexProgramSettings' => [
        'PreferredChannelPipeline' => '',
        'ProgramNumber' => '',
        'ServiceDescriptor' => '',
        'VideoSettings' => ''
    ],
    'programName' => '',
    'requestId' => ''
  ]),
  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}}/prod/multiplexes/:multiplexId/programs', [
  'body' => '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'multiplexProgramSettings' => [
    'PreferredChannelPipeline' => '',
    'ProgramNumber' => '',
    'ServiceDescriptor' => '',
    'VideoSettings' => ''
  ],
  'programName' => '',
  'requestId' => ''
]));

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

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

append(json_encode([
  'multiplexProgramSettings' => [
    'PreferredChannelPipeline' => '',
    'ProgramNumber' => '',
    'ServiceDescriptor' => '',
    'VideoSettings' => ''
  ],
  'programName' => '',
  'requestId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs');
$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}}/prod/multiplexes/:multiplexId/programs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}'

import http.client

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

payload = "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/prod/multiplexes/:multiplexId/programs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs"

payload = {
    "multiplexProgramSettings": {
        "PreferredChannelPipeline": "",
        "ProgramNumber": "",
        "ServiceDescriptor": "",
        "VideoSettings": ""
    },
    "programName": "",
    "requestId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/programs"

payload <- "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\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}}/prod/multiplexes/:multiplexId/programs")

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  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\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/prod/multiplexes/:multiplexId/programs') do |req|
  req.body = "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  },\n  \"programName\": \"\",\n  \"requestId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs";

    let payload = json!({
        "multiplexProgramSettings": json!({
            "PreferredChannelPipeline": "",
            "ProgramNumber": "",
            "ServiceDescriptor": "",
            "VideoSettings": ""
        }),
        "programName": "",
        "requestId": ""
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/programs \
  --header 'content-type: application/json' \
  --data '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}'

echo '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  },
  "programName": "",
  "requestId": ""
}' |  \
  http POST {{baseUrl}}/prod/multiplexes/:multiplexId/programs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "multiplexProgramSettings": {\n    "PreferredChannelPipeline": "",\n    "ProgramNumber": "",\n    "ServiceDescriptor": "",\n    "VideoSettings": ""\n  },\n  "programName": "",\n  "requestId": ""\n}' \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/programs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "multiplexProgramSettings": [
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  ],
  "programName": "",
  "requestId": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreatePartnerInput

{{baseUrl}}/prod/inputs/:inputId/partners

QUERY PARAMS

inputId

BODY json

{
  "requestId": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputs/:inputId/partners");

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  \"requestId\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/inputs/:inputId/partners" {:content-type :json
                                                                          :form-params {:requestId ""
                                                                                        :tags {}}})

require "http/client"

url = "{{baseUrl}}/prod/inputs/:inputId/partners"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"requestId\": \"\",\n  \"tags\": {}\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}}/prod/inputs/:inputId/partners"),
    Content = new StringContent("{\n  \"requestId\": \"\",\n  \"tags\": {}\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}}/prod/inputs/:inputId/partners");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"requestId\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputs/:inputId/partners"

	payload := strings.NewReader("{\n  \"requestId\": \"\",\n  \"tags\": {}\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/prod/inputs/:inputId/partners HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "requestId": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputs/:inputId/partners")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"requestId\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputs/:inputId/partners"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"requestId\": \"\",\n  \"tags\": {}\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  \"requestId\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputs/:inputId/partners")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputs/:inputId/partners")
  .header("content-type", "application/json")
  .body("{\n  \"requestId\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  requestId: '',
  tags: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/prod/inputs/:inputId/partners');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputs/:inputId/partners',
  headers: {'content-type': 'application/json'},
  data: {requestId: '', tags: {}}
};

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

const url = '{{baseUrl}}/prod/inputs/:inputId/partners';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"requestId":"","tags":{}}'
};

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}}/prod/inputs/:inputId/partners',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "requestId": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"requestId\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputs/:inputId/partners")
  .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/prod/inputs/:inputId/partners',
  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({requestId: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputs/:inputId/partners',
  headers: {'content-type': 'application/json'},
  body: {requestId: '', tags: {}},
  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}}/prod/inputs/:inputId/partners');

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

req.type('json');
req.send({
  requestId: '',
  tags: {}
});

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}}/prod/inputs/:inputId/partners',
  headers: {'content-type': 'application/json'},
  data: {requestId: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/prod/inputs/:inputId/partners';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"requestId":"","tags":{}}'
};

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 = @{ @"requestId": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputs/:inputId/partners"]
                                                       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}}/prod/inputs/:inputId/partners" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"requestId\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/prod/inputs/:inputId/partners",
  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([
    'requestId' => '',
    'tags' => [
        
    ]
  ]),
  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}}/prod/inputs/:inputId/partners', [
  'body' => '{
  "requestId": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputs/:inputId/partners');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'requestId' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'requestId' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputs/:inputId/partners');
$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}}/prod/inputs/:inputId/partners' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "requestId": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputs/:inputId/partners' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "requestId": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"requestId\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/prod/inputs/:inputId/partners", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/inputs/:inputId/partners"

payload = {
    "requestId": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputs/:inputId/partners"

payload <- "{\n  \"requestId\": \"\",\n  \"tags\": {}\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}}/prod/inputs/:inputId/partners")

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  \"requestId\": \"\",\n  \"tags\": {}\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/prod/inputs/:inputId/partners') do |req|
  req.body = "{\n  \"requestId\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputs/:inputId/partners";

    let payload = json!({
        "requestId": "",
        "tags": json!({})
    });

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

curl --request POST \
  --url {{baseUrl}}/prod/inputs/:inputId/partners \
  --header 'content-type: application/json' \
  --data '{
  "requestId": "",
  "tags": {}
}'

echo '{
  "requestId": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/prod/inputs/:inputId/partners \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "requestId": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputs/:inputId/partners

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "requestId": "",
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateTags

{{baseUrl}}/prod/tags/:resource-arn

QUERY PARAMS

resource-arn

BODY json

{
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/tags/:resource-arn");

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  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/prod/tags/:resource-arn" {:content-type :json
                                                                    :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/prod/tags/:resource-arn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {}\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}}/prod/tags/:resource-arn"),
    Content = new StringContent("{\n  \"tags\": {}\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}}/prod/tags/:resource-arn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/tags/:resource-arn"

	payload := strings.NewReader("{\n  \"tags\": {}\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/prod/tags/:resource-arn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/tags/:resource-arn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/tags/:resource-arn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {}\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  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/tags/:resource-arn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/prod/tags/:resource-arn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  tags: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/prod/tags/:resource-arn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/tags/:resource-arn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

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

const url = '{{baseUrl}}/prod/tags/:resource-arn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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}}/prod/tags/:resource-arn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/tags/:resource-arn")
  .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/prod/tags/:resource-arn',
  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({tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/tags/:resource-arn',
  headers: {'content-type': 'application/json'},
  body: {tags: {}},
  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}}/prod/tags/:resource-arn');

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

req.type('json');
req.send({
  tags: {}
});

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}}/prod/tags/:resource-arn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

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

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

const url = '{{baseUrl}}/prod/tags/:resource-arn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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 = @{ @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/tags/:resource-arn"]
                                                       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}}/prod/tags/:resource-arn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/prod/tags/:resource-arn",
  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([
    'tags' => [
        
    ]
  ]),
  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}}/prod/tags/:resource-arn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/tags/:resource-arn');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/tags/:resource-arn');
$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}}/prod/tags/:resource-arn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/tags/:resource-arn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

import http.client

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

payload = "{\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/prod/tags/:resource-arn", payload, headers)

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

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

import requests

url = "{{baseUrl}}/prod/tags/:resource-arn"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/tags/:resource-arn"

payload <- "{\n  \"tags\": {}\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}}/prod/tags/:resource-arn")

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  \"tags\": {}\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/prod/tags/:resource-arn') do |req|
  req.body = "{\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/tags/:resource-arn";

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

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

curl --request POST \
  --url {{baseUrl}}/prod/tags/:resource-arn \
  --header 'content-type: application/json' \
  --data '{
  "tags": {}
}'

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/prod/tags/:resource-arn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/prod/tags/:resource-arn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": []] as [String : Any]

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

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

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

dataTask.resume()

DELETE DeleteChannel

{{baseUrl}}/prod/channels/:channelId

QUERY PARAMS

channelId

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/channels/:channelId")

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/prod/channels/:channelId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/channels/: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: 'DELETE', url: '{{baseUrl}}/prod/channels/:channelId'};

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

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

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

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

 "{{baseUrl}}/prod/channels/:channelId",
  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}}/prod/channels/:channelId');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/prod/channels/:channelId")

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

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

import requests

url = "{{baseUrl}}/prod/channels/:channelId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/channels/:channelId")

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/prod/channels/:channelId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/channels/:channelId

http DELETE {{baseUrl}}/prod/channels/:channelId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId

import Foundation

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

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

dataTask.resume()

DELETE DeleteInput

{{baseUrl}}/prod/inputs/:inputId

QUERY PARAMS

inputId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputs/:inputId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/inputs/:inputId")

require "http/client"

url = "{{baseUrl}}/prod/inputs/:inputId"

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

var client = new RestClient("{{baseUrl}}/prod/inputs/:inputId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputs/:inputId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/prod/inputs/:inputId'};

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

const url = '{{baseUrl}}/prod/inputs/:inputId';
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}}/prod/inputs/:inputId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputs/:inputId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputs/:inputId',
  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}}/prod/inputs/:inputId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/inputs/:inputId');

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}}/prod/inputs/:inputId'};

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

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

const url = '{{baseUrl}}/prod/inputs/:inputId';
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}}/prod/inputs/:inputId"]
                                                       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}}/prod/inputs/:inputId" in

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

 "{{baseUrl}}/prod/inputs/:inputId",
  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}}/prod/inputs/:inputId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputs/:inputId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/prod/inputs/:inputId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputs/:inputId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputs/:inputId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/inputs/:inputId")

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

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

import requests

url = "{{baseUrl}}/prod/inputs/:inputId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputs/:inputId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputs/:inputId")

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/prod/inputs/:inputId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/inputs/:inputId

http DELETE {{baseUrl}}/prod/inputs/:inputId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/inputs/:inputId

import Foundation

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

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

dataTask.resume()

DELETE DeleteInputSecurityGroup

{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

QUERY PARAMS

inputSecurityGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")

require "http/client"

url = "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

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

var client = new RestClient("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId'
};

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

const url = '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId';
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}}/prod/inputSecurityGroups/:inputSecurityGroupId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputSecurityGroups/:inputSecurityGroupId',
  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}}/prod/inputSecurityGroups/:inputSecurityGroupId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');

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}}/prod/inputSecurityGroups/:inputSecurityGroupId'
};

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

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

const url = '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId';
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}}/prod/inputSecurityGroups/:inputSecurityGroupId"]
                                                       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}}/prod/inputSecurityGroups/:inputSecurityGroupId" in

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

 "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId",
  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}}/prod/inputSecurityGroups/:inputSecurityGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/inputSecurityGroups/:inputSecurityGroupId")

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

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

import requests

url = "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")

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/prod/inputSecurityGroups/:inputSecurityGroupId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

http DELETE {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

import Foundation

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

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

dataTask.resume()

DELETE DeleteMultiplex

{{baseUrl}}/prod/multiplexes/:multiplexId

QUERY PARAMS

multiplexId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/multiplexes/:multiplexId")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId"

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

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId'
};

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId';
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}}/prod/multiplexes/:multiplexId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/multiplexes/:multiplexId',
  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}}/prod/multiplexes/:multiplexId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/multiplexes/:multiplexId');

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}}/prod/multiplexes/:multiplexId'
};

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

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId';
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}}/prod/multiplexes/:multiplexId"]
                                                       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}}/prod/multiplexes/:multiplexId" in

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

 "{{baseUrl}}/prod/multiplexes/:multiplexId",
  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}}/prod/multiplexes/:multiplexId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/multiplexes/:multiplexId")

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

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

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId")

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/prod/multiplexes/:multiplexId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId

http DELETE {{baseUrl}}/prod/multiplexes/:multiplexId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId

import Foundation

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

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

dataTask.resume()

DELETE DeleteMultiplexProgram

{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

QUERY PARAMS

multiplexId

programName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

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

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

	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/prod/multiplexes/:multiplexId/programs/:programName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"))
    .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}}/prod/multiplexes/:multiplexId/programs/:programName")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .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}}/prod/multiplexes/:multiplexId/programs/:programName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName'
};

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName';
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}}/prod/multiplexes/:multiplexId/programs/:programName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/multiplexes/:multiplexId/programs/:programName',
  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}}/prod/multiplexes/:multiplexId/programs/:programName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');

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}}/prod/multiplexes/:multiplexId/programs/:programName'
};

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

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName';
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}}/prod/multiplexes/:multiplexId/programs/:programName"]
                                                       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}}/prod/multiplexes/:multiplexId/programs/:programName" in

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

 "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName",
  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}}/prod/multiplexes/:multiplexId/programs/:programName');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/multiplexes/:multiplexId/programs/:programName")

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

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

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")

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/prod/multiplexes/:multiplexId/programs/:programName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

http DELETE {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

DELETE DeleteReservation

{{baseUrl}}/prod/reservations/:reservationId

QUERY PARAMS

reservationId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/reservations/:reservationId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/reservations/:reservationId")

require "http/client"

url = "{{baseUrl}}/prod/reservations/:reservationId"

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

var client = new RestClient("{{baseUrl}}/prod/reservations/:reservationId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/reservations/:reservationId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/prod/reservations/:reservationId'
};

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

const url = '{{baseUrl}}/prod/reservations/:reservationId';
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}}/prod/reservations/:reservationId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/reservations/:reservationId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/reservations/:reservationId',
  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}}/prod/reservations/:reservationId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/reservations/:reservationId');

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}}/prod/reservations/:reservationId'
};

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

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

const url = '{{baseUrl}}/prod/reservations/:reservationId';
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}}/prod/reservations/:reservationId"]
                                                       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}}/prod/reservations/:reservationId" in

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

 "{{baseUrl}}/prod/reservations/:reservationId",
  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}}/prod/reservations/:reservationId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/reservations/:reservationId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/prod/reservations/:reservationId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/reservations/:reservationId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/reservations/:reservationId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/reservations/:reservationId")

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

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

import requests

url = "{{baseUrl}}/prod/reservations/:reservationId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/reservations/:reservationId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/reservations/:reservationId")

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/prod/reservations/:reservationId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/reservations/:reservationId

http DELETE {{baseUrl}}/prod/reservations/:reservationId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/reservations/:reservationId

import Foundation

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

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

dataTask.resume()

DELETE DeleteSchedule

{{baseUrl}}/prod/channels/:channelId/schedule

QUERY PARAMS

channelId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId/schedule");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/channels/:channelId/schedule")

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId/schedule"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId/schedule"

	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/prod/channels/:channelId/schedule HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/prod/channels/:channelId/schedule'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/schedule")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/channels/:channelId/schedule');

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}}/prod/channels/:channelId/schedule'
};

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

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

const url = '{{baseUrl}}/prod/channels/:channelId/schedule';
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}}/prod/channels/:channelId/schedule"]
                                                       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}}/prod/channels/:channelId/schedule" in

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

 "{{baseUrl}}/prod/channels/:channelId/schedule",
  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}}/prod/channels/:channelId/schedule');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId/schedule');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/channels/:channelId/schedule' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId/schedule' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/channels/:channelId/schedule")

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

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

import requests

url = "{{baseUrl}}/prod/channels/:channelId/schedule"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId/schedule"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/channels/:channelId/schedule")

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/prod/channels/:channelId/schedule') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/prod/channels/:channelId/schedule

http DELETE {{baseUrl}}/prod/channels/:channelId/schedule

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId/schedule

import Foundation

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

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

dataTask.resume()

DELETE DeleteTags

{{baseUrl}}/prod/tags/:resource-arn#tagKeys

QUERY PARAMS

tagKeys

resource-arn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/prod/tags/:resource-arn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys"

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}}/prod/tags/:resource-arn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys"

	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/prod/tags/:resource-arn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys"))
    .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}}/prod/tags/:resource-arn?tagKeys=#tagKeys")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys")
  .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}}/prod/tags/:resource-arn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/prod/tags/:resource-arn#tagKeys',
  params: {tagKeys: ''}
};

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

const url = '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys';
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}}/prod/tags/:resource-arn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/tags/:resource-arn?tagKeys=',
  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}}/prod/tags/:resource-arn#tagKeys',
  qs: {tagKeys: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/prod/tags/:resource-arn#tagKeys');

req.query({
  tagKeys: ''
});

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}}/prod/tags/:resource-arn#tagKeys',
  params: {tagKeys: ''}
};

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

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

const url = '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys';
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}}/prod/tags/:resource-arn?tagKeys=#tagKeys"]
                                                       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}}/prod/tags/:resource-arn?tagKeys=#tagKeys" in

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

 "{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys",
  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}}/prod/tags/:resource-arn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/tags/:resource-arn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/prod/tags/:resource-arn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/prod/tags/:resource-arn?tagKeys=")

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

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

import requests

url = "{{baseUrl}}/prod/tags/:resource-arn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/tags/:resource-arn#tagKeys"

queryString <- list(tagKeys = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys")

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/prod/tags/:resource-arn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/tags/:resource-arn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

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

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys'

http DELETE '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/tags/:resource-arn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

GET DescribeChannel

{{baseUrl}}/prod/channels/:channelId

QUERY PARAMS

channelId

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/channels/:channelId")

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/prod/channels/:channelId")

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

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

import requests

url = "{{baseUrl}}/prod/channels/:channelId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/channels/:channelId

http GET {{baseUrl}}/prod/channels/:channelId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId

import Foundation

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

GET DescribeInput

{{baseUrl}}/prod/inputs/:inputId

QUERY PARAMS

inputId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputs/:inputId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/inputs/:inputId")

require "http/client"

url = "{{baseUrl}}/prod/inputs/:inputId"

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

var client = new RestClient("{{baseUrl}}/prod/inputs/:inputId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputs/:inputId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/inputs/:inputId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputs/:inputId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputs/:inputId');

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}}/prod/inputs/:inputId'};

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

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

const url = '{{baseUrl}}/prod/inputs/:inputId';
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}}/prod/inputs/:inputId"]
                                                       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}}/prod/inputs/:inputId" in

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

 "{{baseUrl}}/prod/inputs/:inputId",
  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}}/prod/inputs/:inputId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputs/:inputId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/prod/inputs/:inputId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputs/:inputId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputs/:inputId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/prod/inputs/:inputId")

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

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

import requests

url = "{{baseUrl}}/prod/inputs/:inputId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputs/:inputId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputs/:inputId")

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/prod/inputs/:inputId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/inputs/:inputId

http GET {{baseUrl}}/prod/inputs/:inputId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/inputs/:inputId

import Foundation

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

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

dataTask.resume()

GET DescribeInputDevice

{{baseUrl}}/prod/inputDevices/:inputDeviceId

QUERY PARAMS

inputDeviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/inputDevices/:inputDeviceId")

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

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

var client = new RestClient("{{baseUrl}}/prod/inputDevices/:inputDeviceId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputDevices/:inputDeviceId');

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}}/prod/inputDevices/:inputDeviceId'
};

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

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId';
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}}/prod/inputDevices/:inputDeviceId"]
                                                       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}}/prod/inputDevices/:inputDeviceId" in

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

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId",
  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}}/prod/inputDevices/:inputDeviceId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/prod/inputDevices/:inputDeviceId")

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

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

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices/:inputDeviceId")

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/prod/inputDevices/:inputDeviceId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId

http GET {{baseUrl}}/prod/inputDevices/:inputDeviceId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId

import Foundation

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

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

dataTask.resume()

GET DescribeInputDeviceThumbnail

{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept

HEADERS

QUERY PARAMS

inputDeviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept" {:headers {:accept ""}})

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"
headers = HTTP::Headers{
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"

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

	req.Header.Add("accept", "")

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

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

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

}

GET /baseUrl/prod/inputDevices/:inputDeviceId/thumbnailData HTTP/1.1
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"))
    .header("accept", "")
    .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}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept")
  .get()
  .addHeader("accept", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept")
  .header("accept", "")
  .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}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept',
  headers: {accept: ''}
};

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept';
const options = {method: 'GET', headers: {accept: ''}};

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}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept',
  method: 'GET',
  headers: {
    accept: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept")
  .get()
  .addHeader("accept", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDevices/:inputDeviceId/thumbnailData',
  headers: {
    accept: ''
  }
};

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}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept',
  headers: {accept: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept');

req.headers({
  accept: ''
});

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}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept',
  headers: {accept: ''}
};

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

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

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept';
const options = {method: 'GET', headers: {accept: ''}};

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

#import 

NSDictionary *headers = @{ @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept" in
let headers = Header.add (Header.init ()) "accept" "" in

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

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept', [
  'headers' => [
    'accept' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept' -Method GET -Headers $headers

import http.client

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

headers = { 'accept': "" }

conn.request("GET", "/baseUrl/prod/inputDevices/:inputDeviceId/thumbnailData", headers=headers)

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

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

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"

headers = {"accept": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept")

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

request = Net::HTTP::Get.new(url)
request["accept"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/prod/inputDevices/:inputDeviceId/thumbnailData') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept' \
  --header 'accept: '

http GET '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept' \
  accept:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept'

import Foundation

let headers = ["accept": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/thumbnailData#accept")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET DescribeInputSecurityGroup

{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

QUERY PARAMS

inputSecurityGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")

require "http/client"

url = "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

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

var client = new RestClient("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');

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}}/prod/inputSecurityGroups/:inputSecurityGroupId'
};

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

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

const url = '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId';
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}}/prod/inputSecurityGroups/:inputSecurityGroupId"]
                                                       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}}/prod/inputSecurityGroups/:inputSecurityGroupId" in

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

 "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId",
  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}}/prod/inputSecurityGroups/:inputSecurityGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/prod/inputSecurityGroups/:inputSecurityGroupId")

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

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

import requests

url = "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")

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/prod/inputSecurityGroups/:inputSecurityGroupId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

http GET {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

import Foundation

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

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

dataTask.resume()

GET DescribeMultiplex

{{baseUrl}}/prod/multiplexes/:multiplexId

QUERY PARAMS

multiplexId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/multiplexes/:multiplexId")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId"

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

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/multiplexes/:multiplexId');

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}}/prod/multiplexes/:multiplexId'
};

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

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId';
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}}/prod/multiplexes/:multiplexId"]
                                                       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}}/prod/multiplexes/:multiplexId" in

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

 "{{baseUrl}}/prod/multiplexes/:multiplexId",
  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}}/prod/multiplexes/:multiplexId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/prod/multiplexes/:multiplexId")

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

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

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId")

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/prod/multiplexes/:multiplexId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId

http GET {{baseUrl}}/prod/multiplexes/:multiplexId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId

import Foundation

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

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

dataTask.resume()

GET DescribeMultiplexProgram

{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

QUERY PARAMS

multiplexId

programName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

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

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

	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/prod/multiplexes/:multiplexId/programs/:programName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .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}}/prod/multiplexes/:multiplexId/programs/:programName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName'
};

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName';
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}}/prod/multiplexes/:multiplexId/programs/:programName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');

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}}/prod/multiplexes/:multiplexId/programs/:programName'
};

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

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

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName';
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}}/prod/multiplexes/:multiplexId/programs/:programName"]
                                                       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}}/prod/multiplexes/:multiplexId/programs/:programName" in

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

 "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName",
  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}}/prod/multiplexes/:multiplexId/programs/:programName');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/prod/multiplexes/:multiplexId/programs/:programName")

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

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

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")

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/prod/multiplexes/:multiplexId/programs/:programName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

http GET {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET DescribeOffering

{{baseUrl}}/prod/offerings/:offeringId

QUERY PARAMS

offeringId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/offerings/:offeringId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/offerings/:offeringId")

require "http/client"

url = "{{baseUrl}}/prod/offerings/:offeringId"

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

var client = new RestClient("{{baseUrl}}/prod/offerings/:offeringId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/offerings/:offeringId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/offerings/:offeringId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/offerings/:offeringId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/offerings/:offeringId');

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}}/prod/offerings/:offeringId'};

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

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

const url = '{{baseUrl}}/prod/offerings/:offeringId';
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}}/prod/offerings/:offeringId"]
                                                       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}}/prod/offerings/:offeringId" in

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

 "{{baseUrl}}/prod/offerings/:offeringId",
  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}}/prod/offerings/:offeringId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/offerings/:offeringId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/prod/offerings/:offeringId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/offerings/:offeringId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/offerings/:offeringId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/prod/offerings/:offeringId")

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

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

import requests

url = "{{baseUrl}}/prod/offerings/:offeringId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/offerings/:offeringId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/offerings/:offeringId")

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/prod/offerings/:offeringId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/offerings/:offeringId

http GET {{baseUrl}}/prod/offerings/:offeringId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/offerings/:offeringId

import Foundation

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

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

dataTask.resume()

GET DescribeReservation

{{baseUrl}}/prod/reservations/:reservationId

QUERY PARAMS

reservationId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/reservations/:reservationId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/prod/reservations/:reservationId")

require "http/client"

url = "{{baseUrl}}/prod/reservations/:reservationId"

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

var client = new RestClient("{{baseUrl}}/prod/reservations/:reservationId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/prod/reservations/:reservationId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/reservations/:reservationId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/reservations/:reservationId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/reservations/:reservationId');

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}}/prod/reservations/:reservationId'
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/reservations/:reservationId';
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}}/prod/reservations/:reservationId"]
                                                       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}}/prod/reservations/:reservationId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/reservations/:reservationId",
  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}}/prod/reservations/:reservationId');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/reservations/:reservationId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/reservations/:reservationId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/reservations/:reservationId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/reservations/:reservationId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/reservations/:reservationId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/reservations/:reservationId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/reservations/:reservationId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/reservations/:reservationId")

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/prod/reservations/:reservationId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/reservations/:reservationId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/reservations/:reservationId

http GET {{baseUrl}}/prod/reservations/:reservationId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/reservations/:reservationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/reservations/:reservationId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET DescribeSchedule

{{baseUrl}}/prod/channels/:channelId/schedule

QUERY PARAMS

channelId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId/schedule");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/channels/:channelId/schedule")

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId/schedule"

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}}/prod/channels/:channelId/schedule"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/channels/:channelId/schedule");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId/schedule"

	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/prod/channels/:channelId/schedule HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/channels/:channelId/schedule")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels/:channelId/schedule"))
    .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}}/prod/channels/:channelId/schedule")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/channels/:channelId/schedule")
  .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}}/prod/channels/:channelId/schedule');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/channels/:channelId/schedule'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/channels/:channelId/schedule';
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}}/prod/channels/:channelId/schedule',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/schedule")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/channels/:channelId/schedule',
  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}}/prod/channels/:channelId/schedule'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/channels/:channelId/schedule');

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}}/prod/channels/:channelId/schedule'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/channels/:channelId/schedule';
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}}/prod/channels/:channelId/schedule"]
                                                       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}}/prod/channels/:channelId/schedule" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/channels/:channelId/schedule",
  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}}/prod/channels/:channelId/schedule');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId/schedule');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/channels/:channelId/schedule');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/channels/:channelId/schedule' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId/schedule' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/channels/:channelId/schedule")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/channels/:channelId/schedule"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId/schedule"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/channels/:channelId/schedule")

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/prod/channels/:channelId/schedule') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/channels/:channelId/schedule";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/channels/:channelId/schedule

http GET {{baseUrl}}/prod/channels/:channelId/schedule

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId/schedule

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/channels/:channelId/schedule")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListChannels

{{baseUrl}}/prod/channels

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/channels")

require "http/client"

url = "{{baseUrl}}/prod/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}}/prod/channels"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/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/prod/channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/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}}/prod/channels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/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}}/prod/channels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/channels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/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}}/prod/channels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/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}}/prod/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}}/prod/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}}/prod/channels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/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}}/prod/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}}/prod/channels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/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}}/prod/channels');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/channels' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/channels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/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/prod/channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/channels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/channels

http GET {{baseUrl}}/prod/channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/channels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInputDeviceTransfers

{{baseUrl}}/prod/inputDeviceTransfers#transferType

QUERY PARAMS

transferType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/inputDeviceTransfers#transferType" {:query-params {:transferType ""}})

require "http/client"

url = "{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType"

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}}/prod/inputDeviceTransfers?transferType=#transferType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType"

	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/prod/inputDeviceTransfers?transferType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType"))
    .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}}/prod/inputDeviceTransfers?transferType=#transferType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType")
  .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}}/prod/inputDeviceTransfers?transferType=#transferType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/inputDeviceTransfers#transferType',
  params: {transferType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType';
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}}/prod/inputDeviceTransfers?transferType=#transferType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDeviceTransfers?transferType=',
  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}}/prod/inputDeviceTransfers#transferType',
  qs: {transferType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputDeviceTransfers#transferType');

req.query({
  transferType: ''
});

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}}/prod/inputDeviceTransfers#transferType',
  params: {transferType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType';
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}}/prod/inputDeviceTransfers?transferType=#transferType"]
                                                       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}}/prod/inputDeviceTransfers?transferType=#transferType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType",
  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}}/prod/inputDeviceTransfers?transferType=#transferType');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDeviceTransfers#transferType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'transferType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/inputDeviceTransfers#transferType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'transferType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/inputDeviceTransfers?transferType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDeviceTransfers#transferType"

querystring = {"transferType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDeviceTransfers#transferType"

queryString <- list(transferType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType")

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/prod/inputDeviceTransfers') do |req|
  req.params['transferType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDeviceTransfers#transferType";

    let querystring = [
        ("transferType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType'

http GET '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDeviceTransfers?transferType=#transferType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInputDevices

{{baseUrl}}/prod/inputDevices

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/inputDevices")

require "http/client"

url = "{{baseUrl}}/prod/inputDevices"

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}}/prod/inputDevices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputDevices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDevices"

	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/prod/inputDevices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/inputDevices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices"))
    .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}}/prod/inputDevices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/inputDevices")
  .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}}/prod/inputDevices');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/inputDevices'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDevices';
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}}/prod/inputDevices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDevices',
  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}}/prod/inputDevices'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputDevices');

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}}/prod/inputDevices'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDevices';
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}}/prod/inputDevices"]
                                                       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}}/prod/inputDevices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDevices",
  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}}/prod/inputDevices');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/inputDevices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/inputDevices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDevices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices")

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/prod/inputDevices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/inputDevices

http GET {{baseUrl}}/prod/inputDevices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/inputDevices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInputSecurityGroups

{{baseUrl}}/prod/inputSecurityGroups

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputSecurityGroups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/inputSecurityGroups")

require "http/client"

url = "{{baseUrl}}/prod/inputSecurityGroups"

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}}/prod/inputSecurityGroups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputSecurityGroups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputSecurityGroups"

	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/prod/inputSecurityGroups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/inputSecurityGroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputSecurityGroups"))
    .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}}/prod/inputSecurityGroups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/inputSecurityGroups")
  .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}}/prod/inputSecurityGroups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/inputSecurityGroups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputSecurityGroups';
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}}/prod/inputSecurityGroups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputSecurityGroups',
  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}}/prod/inputSecurityGroups'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputSecurityGroups');

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}}/prod/inputSecurityGroups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputSecurityGroups';
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}}/prod/inputSecurityGroups"]
                                                       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}}/prod/inputSecurityGroups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputSecurityGroups",
  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}}/prod/inputSecurityGroups');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputSecurityGroups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/inputSecurityGroups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputSecurityGroups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputSecurityGroups' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/inputSecurityGroups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputSecurityGroups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputSecurityGroups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputSecurityGroups")

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/prod/inputSecurityGroups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputSecurityGroups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/inputSecurityGroups

http GET {{baseUrl}}/prod/inputSecurityGroups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/inputSecurityGroups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputSecurityGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListInputs

{{baseUrl}}/prod/inputs

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/inputs")

require "http/client"

url = "{{baseUrl}}/prod/inputs"

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}}/prod/inputs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputs"

	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/prod/inputs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/inputs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputs"))
    .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}}/prod/inputs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/inputs")
  .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}}/prod/inputs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/inputs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputs';
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}}/prod/inputs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputs',
  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}}/prod/inputs'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/inputs');

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}}/prod/inputs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputs';
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}}/prod/inputs"]
                                                       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}}/prod/inputs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputs",
  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}}/prod/inputs');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/inputs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputs' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/inputs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputs")

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/prod/inputs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/inputs

http GET {{baseUrl}}/prod/inputs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/inputs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListMultiplexPrograms

{{baseUrl}}/prod/multiplexes/:multiplexId/programs

QUERY PARAMS

multiplexId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/programs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/multiplexes/:multiplexId/programs")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId/programs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/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/prod/multiplexes/:multiplexId/programs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/multiplexes/:multiplexId/programs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/multiplexes/:multiplexId/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}}/prod/multiplexes/:multiplexId/programs');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/multiplexes/:multiplexId/programs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/programs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId/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/prod/multiplexes/:multiplexId/programs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/programs

http GET {{baseUrl}}/prod/multiplexes/:multiplexId/programs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/programs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId/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()

GET ListMultiplexes

{{baseUrl}}/prod/multiplexes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/multiplexes")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes"

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}}/prod/multiplexes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/multiplexes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/multiplexes"

	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/prod/multiplexes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/multiplexes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes"))
    .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}}/prod/multiplexes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/multiplexes")
  .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}}/prod/multiplexes');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/multiplexes'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/multiplexes';
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}}/prod/multiplexes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/multiplexes',
  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}}/prod/multiplexes'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/multiplexes');

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}}/prod/multiplexes'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/multiplexes';
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}}/prod/multiplexes"]
                                                       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}}/prod/multiplexes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/multiplexes",
  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}}/prod/multiplexes');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/multiplexes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/multiplexes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/multiplexes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes")

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/prod/multiplexes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/multiplexes

http GET {{baseUrl}}/prod/multiplexes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/multiplexes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListOfferings

{{baseUrl}}/prod/offerings

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/offerings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/offerings")

require "http/client"

url = "{{baseUrl}}/prod/offerings"

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}}/prod/offerings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/offerings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/offerings"

	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/prod/offerings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/offerings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/offerings"))
    .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}}/prod/offerings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/offerings")
  .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}}/prod/offerings');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/offerings'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/offerings';
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}}/prod/offerings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/offerings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/offerings',
  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}}/prod/offerings'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/offerings');

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}}/prod/offerings'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/offerings';
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}}/prod/offerings"]
                                                       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}}/prod/offerings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/offerings",
  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}}/prod/offerings');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/offerings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/offerings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/offerings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/offerings' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/offerings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/offerings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/offerings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/offerings")

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/prod/offerings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/offerings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/offerings

http GET {{baseUrl}}/prod/offerings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/offerings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/offerings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListReservations

{{baseUrl}}/prod/reservations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/reservations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/reservations")

require "http/client"

url = "{{baseUrl}}/prod/reservations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/prod/reservations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/reservations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/reservations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/prod/reservations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/reservations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/reservations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/reservations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/reservations")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/prod/reservations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/reservations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/reservations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/prod/reservations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/reservations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/reservations',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/prod/reservations'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/reservations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/prod/reservations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/reservations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/reservations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/prod/reservations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/reservations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/prod/reservations');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/reservations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/reservations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/reservations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/reservations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/reservations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/reservations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/reservations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/reservations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/prod/reservations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/reservations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/reservations

http GET {{baseUrl}}/prod/reservations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/reservations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/reservations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListTagsForResource

{{baseUrl}}/prod/tags/:resource-arn

QUERY PARAMS

resource-arn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/tags/:resource-arn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/prod/tags/:resource-arn")

require "http/client"

url = "{{baseUrl}}/prod/tags/:resource-arn"

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}}/prod/tags/:resource-arn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/tags/:resource-arn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/tags/:resource-arn"

	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/prod/tags/:resource-arn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/prod/tags/:resource-arn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/tags/:resource-arn"))
    .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}}/prod/tags/:resource-arn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/prod/tags/:resource-arn")
  .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}}/prod/tags/:resource-arn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/prod/tags/:resource-arn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/tags/:resource-arn';
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}}/prod/tags/:resource-arn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/tags/:resource-arn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/tags/:resource-arn',
  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}}/prod/tags/:resource-arn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/prod/tags/:resource-arn');

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}}/prod/tags/:resource-arn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/tags/:resource-arn';
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}}/prod/tags/:resource-arn"]
                                                       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}}/prod/tags/:resource-arn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/tags/:resource-arn",
  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}}/prod/tags/:resource-arn');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/tags/:resource-arn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/tags/:resource-arn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/tags/:resource-arn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/tags/:resource-arn' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/prod/tags/:resource-arn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/tags/:resource-arn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/tags/:resource-arn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/tags/:resource-arn")

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/prod/tags/:resource-arn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/tags/:resource-arn";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/prod/tags/:resource-arn

http GET {{baseUrl}}/prod/tags/:resource-arn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/prod/tags/:resource-arn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/tags/:resource-arn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST PurchaseOffering

{{baseUrl}}/prod/offerings/:offeringId/purchase

QUERY PARAMS

offeringId

BODY json

{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/offerings/:offeringId/purchase");

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  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/offerings/:offeringId/purchase" {:content-type :json
                                                                                :form-params {:count 0
                                                                                              :name ""
                                                                                              :renewalSettings {:AutomaticRenewal ""
                                                                                                                :RenewalCount ""}
                                                                                              :requestId ""
                                                                                              :start ""
                                                                                              :tags {}}})

require "http/client"

url = "{{baseUrl}}/prod/offerings/:offeringId/purchase"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\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}}/prod/offerings/:offeringId/purchase"),
    Content = new StringContent("{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\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}}/prod/offerings/:offeringId/purchase");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/offerings/:offeringId/purchase"

	payload := strings.NewReader("{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\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/prod/offerings/:offeringId/purchase HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 157

{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/offerings/:offeringId/purchase")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/offerings/:offeringId/purchase"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\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  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/offerings/:offeringId/purchase")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/offerings/:offeringId/purchase")
  .header("content-type", "application/json")
  .body("{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  count: 0,
  name: '',
  renewalSettings: {
    AutomaticRenewal: '',
    RenewalCount: ''
  },
  requestId: '',
  start: '',
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/prod/offerings/:offeringId/purchase');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/offerings/:offeringId/purchase',
  headers: {'content-type': 'application/json'},
  data: {
    count: 0,
    name: '',
    renewalSettings: {AutomaticRenewal: '', RenewalCount: ''},
    requestId: '',
    start: '',
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/offerings/:offeringId/purchase';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"count":0,"name":"","renewalSettings":{"AutomaticRenewal":"","RenewalCount":""},"requestId":"","start":"","tags":{}}'
};

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}}/prod/offerings/:offeringId/purchase',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "count": 0,\n  "name": "",\n  "renewalSettings": {\n    "AutomaticRenewal": "",\n    "RenewalCount": ""\n  },\n  "requestId": "",\n  "start": "",\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/offerings/:offeringId/purchase")
  .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/prod/offerings/:offeringId/purchase',
  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({
  count: 0,
  name: '',
  renewalSettings: {AutomaticRenewal: '', RenewalCount: ''},
  requestId: '',
  start: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/offerings/:offeringId/purchase',
  headers: {'content-type': 'application/json'},
  body: {
    count: 0,
    name: '',
    renewalSettings: {AutomaticRenewal: '', RenewalCount: ''},
    requestId: '',
    start: '',
    tags: {}
  },
  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}}/prod/offerings/:offeringId/purchase');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  count: 0,
  name: '',
  renewalSettings: {
    AutomaticRenewal: '',
    RenewalCount: ''
  },
  requestId: '',
  start: '',
  tags: {}
});

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}}/prod/offerings/:offeringId/purchase',
  headers: {'content-type': 'application/json'},
  data: {
    count: 0,
    name: '',
    renewalSettings: {AutomaticRenewal: '', RenewalCount: ''},
    requestId: '',
    start: '',
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/offerings/:offeringId/purchase';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"count":0,"name":"","renewalSettings":{"AutomaticRenewal":"","RenewalCount":""},"requestId":"","start":"","tags":{}}'
};

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 = @{ @"count": @0,
                              @"name": @"",
                              @"renewalSettings": @{ @"AutomaticRenewal": @"", @"RenewalCount": @"" },
                              @"requestId": @"",
                              @"start": @"",
                              @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/offerings/:offeringId/purchase"]
                                                       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}}/prod/offerings/:offeringId/purchase" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/offerings/:offeringId/purchase",
  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([
    'count' => 0,
    'name' => '',
    'renewalSettings' => [
        'AutomaticRenewal' => '',
        'RenewalCount' => ''
    ],
    'requestId' => '',
    'start' => '',
    'tags' => [
        
    ]
  ]),
  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}}/prod/offerings/:offeringId/purchase', [
  'body' => '{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/offerings/:offeringId/purchase');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'count' => 0,
  'name' => '',
  'renewalSettings' => [
    'AutomaticRenewal' => '',
    'RenewalCount' => ''
  ],
  'requestId' => '',
  'start' => '',
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'count' => 0,
  'name' => '',
  'renewalSettings' => [
    'AutomaticRenewal' => '',
    'RenewalCount' => ''
  ],
  'requestId' => '',
  'start' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/offerings/:offeringId/purchase');
$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}}/prod/offerings/:offeringId/purchase' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/offerings/:offeringId/purchase' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/prod/offerings/:offeringId/purchase", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/offerings/:offeringId/purchase"

payload = {
    "count": 0,
    "name": "",
    "renewalSettings": {
        "AutomaticRenewal": "",
        "RenewalCount": ""
    },
    "requestId": "",
    "start": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/offerings/:offeringId/purchase"

payload <- "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\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}}/prod/offerings/:offeringId/purchase")

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  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\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/prod/offerings/:offeringId/purchase') do |req|
  req.body = "{\n  \"count\": 0,\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  },\n  \"requestId\": \"\",\n  \"start\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/offerings/:offeringId/purchase";

    let payload = json!({
        "count": 0,
        "name": "",
        "renewalSettings": json!({
            "AutomaticRenewal": "",
            "RenewalCount": ""
        }),
        "requestId": "",
        "start": "",
        "tags": json!({})
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/prod/offerings/:offeringId/purchase \
  --header 'content-type: application/json' \
  --data '{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}'

echo '{
  "count": 0,
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  },
  "requestId": "",
  "start": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/prod/offerings/:offeringId/purchase \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "count": 0,\n  "name": "",\n  "renewalSettings": {\n    "AutomaticRenewal": "",\n    "RenewalCount": ""\n  },\n  "requestId": "",\n  "start": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/prod/offerings/:offeringId/purchase

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "count": 0,
  "name": "",
  "renewalSettings": [
    "AutomaticRenewal": "",
    "RenewalCount": ""
  ],
  "requestId": "",
  "start": "",
  "tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/offerings/:offeringId/purchase")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RebootInputDevice

{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot

QUERY PARAMS

inputDeviceId

BODY json

{
  "force": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot");

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  \"force\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot" {:content-type :json
                                                                                    :form-params {:force ""}})

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"force\": \"\"\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}}/prod/inputDevices/:inputDeviceId/reboot"),
    Content = new StringContent("{\n  \"force\": \"\"\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}}/prod/inputDevices/:inputDeviceId/reboot");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"force\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot"

	payload := strings.NewReader("{\n  \"force\": \"\"\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/prod/inputDevices/:inputDeviceId/reboot HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "force": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"force\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"force\": \"\"\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  \"force\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot")
  .header("content-type", "application/json")
  .body("{\n  \"force\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  force: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot',
  headers: {'content-type': 'application/json'},
  data: {force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"force":""}'
};

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}}/prod/inputDevices/:inputDeviceId/reboot',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "force": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"force\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot")
  .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/prod/inputDevices/:inputDeviceId/reboot',
  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({force: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot',
  headers: {'content-type': 'application/json'},
  body: {force: ''},
  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}}/prod/inputDevices/:inputDeviceId/reboot');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  force: ''
});

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}}/prod/inputDevices/:inputDeviceId/reboot',
  headers: {'content-type': 'application/json'},
  data: {force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"force":""}'
};

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 = @{ @"force": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot"]
                                                       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}}/prod/inputDevices/:inputDeviceId/reboot" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"force\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot",
  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([
    'force' => ''
  ]),
  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}}/prod/inputDevices/:inputDeviceId/reboot', [
  'body' => '{
  "force": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'force' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'force' => ''
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot');
$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}}/prod/inputDevices/:inputDeviceId/reboot' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "force": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "force": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"force\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/prod/inputDevices/:inputDeviceId/reboot", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot"

payload = { "force": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot"

payload <- "{\n  \"force\": \"\"\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}}/prod/inputDevices/:inputDeviceId/reboot")

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  \"force\": \"\"\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/prod/inputDevices/:inputDeviceId/reboot') do |req|
  req.body = "{\n  \"force\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot";

    let payload = json!({"force": ""});

    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);
}

curl --request POST \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot \
  --header 'content-type: application/json' \
  --data '{
  "force": ""
}'

echo '{
  "force": ""
}' |  \
  http POST {{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "force": ""\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["force": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reboot")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RejectInputDeviceTransfer

{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject

QUERY PARAMS

inputDeviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject")

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject"

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}}/prod/inputDevices/:inputDeviceId/reject"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject"

	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/prod/inputDevices/:inputDeviceId/reject HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject"))
    .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}}/prod/inputDevices/:inputDeviceId/reject")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject")
  .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}}/prod/inputDevices/:inputDeviceId/reject');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject';
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}}/prod/inputDevices/:inputDeviceId/reject',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDevices/:inputDeviceId/reject',
  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}}/prod/inputDevices/:inputDeviceId/reject'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject');

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}}/prod/inputDevices/:inputDeviceId/reject'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject';
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}}/prod/inputDevices/:inputDeviceId/reject"]
                                                       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}}/prod/inputDevices/:inputDeviceId/reject" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject",
  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}}/prod/inputDevices/:inputDeviceId/reject');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/prod/inputDevices/:inputDeviceId/reject")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject")

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/prod/inputDevices/:inputDeviceId/reject') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId/reject

http POST {{baseUrl}}/prod/inputDevices/:inputDeviceId/reject

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId/reject

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/reject")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartChannel

{{baseUrl}}/prod/channels/:channelId/start

QUERY PARAMS

channelId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId/start");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/channels/:channelId/start")

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId/start"

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}}/prod/channels/:channelId/start"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/channels/:channelId/start");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId/start"

	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/prod/channels/:channelId/start HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/channels/:channelId/start")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels/:channelId/start"))
    .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}}/prod/channels/:channelId/start")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/channels/:channelId/start")
  .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}}/prod/channels/:channelId/start');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/channels/:channelId/start'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/channels/:channelId/start';
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}}/prod/channels/:channelId/start',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/start")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/channels/:channelId/start',
  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}}/prod/channels/:channelId/start'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/channels/:channelId/start');

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}}/prod/channels/:channelId/start'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/channels/:channelId/start';
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}}/prod/channels/:channelId/start"]
                                                       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}}/prod/channels/:channelId/start" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/channels/:channelId/start",
  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}}/prod/channels/:channelId/start');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId/start');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/channels/:channelId/start');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/channels/:channelId/start' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId/start' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/prod/channels/:channelId/start")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/channels/:channelId/start"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId/start"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/channels/:channelId/start")

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/prod/channels/:channelId/start') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/channels/:channelId/start";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/channels/:channelId/start

http POST {{baseUrl}}/prod/channels/:channelId/start

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId/start

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/channels/:channelId/start")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartInputDeviceMaintenanceWindow

{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow

QUERY PARAMS

inputDeviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"

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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"

	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/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"))
    .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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")
  .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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow';
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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow',
  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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow');

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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow';
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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"]
                                                       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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow",
  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}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")

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/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow

http POST {{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/startInputDeviceMaintenanceWindow")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartMultiplex

{{baseUrl}}/prod/multiplexes/:multiplexId/start

QUERY PARAMS

multiplexId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/start");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/multiplexes/:multiplexId/start")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/start"

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}}/prod/multiplexes/:multiplexId/start"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId/start");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/start"

	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/prod/multiplexes/:multiplexId/start HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/multiplexes/:multiplexId/start")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId/start"))
    .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}}/prod/multiplexes/:multiplexId/start")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/multiplexes/:multiplexId/start")
  .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}}/prod/multiplexes/:multiplexId/start');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/start'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/start';
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}}/prod/multiplexes/:multiplexId/start',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/start")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/multiplexes/:multiplexId/start',
  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}}/prod/multiplexes/:multiplexId/start'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/multiplexes/:multiplexId/start');

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}}/prod/multiplexes/:multiplexId/start'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/start';
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}}/prod/multiplexes/:multiplexId/start"]
                                                       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}}/prod/multiplexes/:multiplexId/start" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/multiplexes/:multiplexId/start",
  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}}/prod/multiplexes/:multiplexId/start');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/start');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/start');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/start' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/start' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/prod/multiplexes/:multiplexId/start")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/start"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/start"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId/start")

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/prod/multiplexes/:multiplexId/start') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes/:multiplexId/start";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/start

http POST {{baseUrl}}/prod/multiplexes/:multiplexId/start

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/start

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId/start")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopChannel

{{baseUrl}}/prod/channels/:channelId/stop

QUERY PARAMS

channelId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId/stop");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/channels/:channelId/stop")

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId/stop"

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}}/prod/channels/:channelId/stop"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/channels/:channelId/stop");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId/stop"

	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/prod/channels/:channelId/stop HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/channels/:channelId/stop")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels/:channelId/stop"))
    .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}}/prod/channels/:channelId/stop")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/channels/:channelId/stop")
  .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}}/prod/channels/:channelId/stop');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/channels/:channelId/stop'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/channels/:channelId/stop';
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}}/prod/channels/:channelId/stop',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/stop")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/channels/:channelId/stop',
  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}}/prod/channels/:channelId/stop'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/channels/:channelId/stop');

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}}/prod/channels/:channelId/stop'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/channels/:channelId/stop';
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}}/prod/channels/:channelId/stop"]
                                                       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}}/prod/channels/:channelId/stop" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/channels/:channelId/stop",
  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}}/prod/channels/:channelId/stop');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId/stop');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/channels/:channelId/stop');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/channels/:channelId/stop' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId/stop' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/prod/channels/:channelId/stop")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/channels/:channelId/stop"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId/stop"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/channels/:channelId/stop")

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/prod/channels/:channelId/stop') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/channels/:channelId/stop";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/channels/:channelId/stop

http POST {{baseUrl}}/prod/channels/:channelId/stop

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId/stop

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/channels/:channelId/stop")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopMultiplex

{{baseUrl}}/prod/multiplexes/:multiplexId/stop

QUERY PARAMS

multiplexId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/stop");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/multiplexes/:multiplexId/stop")

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/stop"

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}}/prod/multiplexes/:multiplexId/stop"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/prod/multiplexes/:multiplexId/stop");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/stop"

	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/prod/multiplexes/:multiplexId/stop HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/multiplexes/:multiplexId/stop")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId/stop"))
    .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}}/prod/multiplexes/:multiplexId/stop")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/multiplexes/:multiplexId/stop")
  .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}}/prod/multiplexes/:multiplexId/stop');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/stop'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/stop';
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}}/prod/multiplexes/:multiplexId/stop',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/stop")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/prod/multiplexes/:multiplexId/stop',
  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}}/prod/multiplexes/:multiplexId/stop'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/prod/multiplexes/:multiplexId/stop');

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}}/prod/multiplexes/:multiplexId/stop'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/stop';
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}}/prod/multiplexes/:multiplexId/stop"]
                                                       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}}/prod/multiplexes/:multiplexId/stop" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/multiplexes/:multiplexId/stop",
  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}}/prod/multiplexes/:multiplexId/stop');

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/stop');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/stop');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/stop' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/stop' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/prod/multiplexes/:multiplexId/stop")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/stop"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/stop"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/prod/multiplexes/:multiplexId/stop")

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/prod/multiplexes/:multiplexId/stop') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/multiplexes/:multiplexId/stop";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/stop

http POST {{baseUrl}}/prod/multiplexes/:multiplexId/stop

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/stop

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId/stop")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TransferInputDevice

{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer

QUERY PARAMS

inputDeviceId

BODY json

{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer");

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  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer" {:content-type :json
                                                                                      :form-params {:targetCustomerId ""
                                                                                                    :targetRegion ""
                                                                                                    :transferMessage ""}})

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\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}}/prod/inputDevices/:inputDeviceId/transfer"),
    Content = new StringContent("{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\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}}/prod/inputDevices/:inputDeviceId/transfer");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer"

	payload := strings.NewReader("{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\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/prod/inputDevices/:inputDeviceId/transfer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\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  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer")
  .header("content-type", "application/json")
  .body("{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  targetCustomerId: '',
  targetRegion: '',
  transferMessage: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer',
  headers: {'content-type': 'application/json'},
  data: {targetCustomerId: '', targetRegion: '', transferMessage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"targetCustomerId":"","targetRegion":"","transferMessage":""}'
};

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}}/prod/inputDevices/:inputDeviceId/transfer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "targetCustomerId": "",\n  "targetRegion": "",\n  "transferMessage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer")
  .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/prod/inputDevices/:inputDeviceId/transfer',
  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({targetCustomerId: '', targetRegion: '', transferMessage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer',
  headers: {'content-type': 'application/json'},
  body: {targetCustomerId: '', targetRegion: '', transferMessage: ''},
  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}}/prod/inputDevices/:inputDeviceId/transfer');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  targetCustomerId: '',
  targetRegion: '',
  transferMessage: ''
});

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}}/prod/inputDevices/:inputDeviceId/transfer',
  headers: {'content-type': 'application/json'},
  data: {targetCustomerId: '', targetRegion: '', transferMessage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"targetCustomerId":"","targetRegion":"","transferMessage":""}'
};

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 = @{ @"targetCustomerId": @"",
                              @"targetRegion": @"",
                              @"transferMessage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer"]
                                                       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}}/prod/inputDevices/:inputDeviceId/transfer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer",
  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([
    'targetCustomerId' => '',
    'targetRegion' => '',
    'transferMessage' => ''
  ]),
  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}}/prod/inputDevices/:inputDeviceId/transfer', [
  'body' => '{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'targetCustomerId' => '',
  'targetRegion' => '',
  'transferMessage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'targetCustomerId' => '',
  'targetRegion' => '',
  'transferMessage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer');
$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}}/prod/inputDevices/:inputDeviceId/transfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/prod/inputDevices/:inputDeviceId/transfer", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer"

payload = {
    "targetCustomerId": "",
    "targetRegion": "",
    "transferMessage": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer"

payload <- "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\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}}/prod/inputDevices/:inputDeviceId/transfer")

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  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\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/prod/inputDevices/:inputDeviceId/transfer') do |req|
  req.body = "{\n  \"targetCustomerId\": \"\",\n  \"targetRegion\": \"\",\n  \"transferMessage\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer";

    let payload = json!({
        "targetCustomerId": "",
        "targetRegion": "",
        "transferMessage": ""
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer \
  --header 'content-type: application/json' \
  --data '{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}'

echo '{
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
}' |  \
  http POST {{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "targetCustomerId": "",\n  "targetRegion": "",\n  "transferMessage": ""\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "targetCustomerId": "",
  "targetRegion": "",
  "transferMessage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId/transfer")! 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()

PUT UpdateChannel

{{baseUrl}}/prod/channels/:channelId

QUERY PARAMS

channelId

BODY json

{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId");

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  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/channels/:channelId" {:content-type :json
                                                                    :form-params {:cdiInputSpecification {:Resolution ""}
                                                                                  :destinations [{:Id ""
                                                                                                  :MediaPackageSettings ""
                                                                                                  :MultiplexSettings ""
                                                                                                  :Settings ""}]
                                                                                  :encoderSettings {:AudioDescriptions ""
                                                                                                    :AvailBlanking ""
                                                                                                    :AvailConfiguration ""
                                                                                                    :BlackoutSlate ""
                                                                                                    :CaptionDescriptions ""
                                                                                                    :FeatureActivations ""
                                                                                                    :GlobalConfiguration ""
                                                                                                    :MotionGraphicsConfiguration ""
                                                                                                    :NielsenConfiguration ""
                                                                                                    :OutputGroups ""
                                                                                                    :TimecodeConfig ""
                                                                                                    :VideoDescriptions ""}
                                                                                  :inputAttachments [{:AutomaticInputFailoverSettings ""
                                                                                                      :InputAttachmentName ""
                                                                                                      :InputId ""
                                                                                                      :InputSettings ""}]
                                                                                  :inputSpecification {:Codec ""
                                                                                                       :MaximumBitrate ""
                                                                                                       :Resolution ""}
                                                                                  :logLevel ""
                                                                                  :maintenance {:MaintenanceDay ""
                                                                                                :MaintenanceScheduledDate ""
                                                                                                :MaintenanceStartTime ""}
                                                                                  :name ""
                                                                                  :roleArn ""}})

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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}}/prod/channels/:channelId"),
    Content = new StringContent("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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}}/prod/channels/:channelId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId"

	payload := strings.NewReader("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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/prod/channels/:channelId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1000

{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/channels/:channelId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels/:channelId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/channels/:channelId")
  .header("content-type", "application/json")
  .body("{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cdiInputSpecification: {
    Resolution: ''
  },
  destinations: [
    {
      Id: '',
      MediaPackageSettings: '',
      MultiplexSettings: '',
      Settings: ''
    }
  ],
  encoderSettings: {
    AudioDescriptions: '',
    AvailBlanking: '',
    AvailConfiguration: '',
    BlackoutSlate: '',
    CaptionDescriptions: '',
    FeatureActivations: '',
    GlobalConfiguration: '',
    MotionGraphicsConfiguration: '',
    NielsenConfiguration: '',
    OutputGroups: '',
    TimecodeConfig: '',
    VideoDescriptions: ''
  },
  inputAttachments: [
    {
      AutomaticInputFailoverSettings: '',
      InputAttachmentName: '',
      InputId: '',
      InputSettings: ''
    }
  ],
  inputSpecification: {
    Codec: '',
    MaximumBitrate: '',
    Resolution: ''
  },
  logLevel: '',
  maintenance: {
    MaintenanceDay: '',
    MaintenanceScheduledDate: '',
    MaintenanceStartTime: ''
  },
  name: '',
  roleArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/channels/:channelId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/channels/:channelId',
  headers: {'content-type': 'application/json'},
  data: {
    cdiInputSpecification: {Resolution: ''},
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
    encoderSettings: {
      AudioDescriptions: '',
      AvailBlanking: '',
      AvailConfiguration: '',
      BlackoutSlate: '',
      CaptionDescriptions: '',
      FeatureActivations: '',
      GlobalConfiguration: '',
      MotionGraphicsConfiguration: '',
      NielsenConfiguration: '',
      OutputGroups: '',
      TimecodeConfig: '',
      VideoDescriptions: ''
    },
    inputAttachments: [
      {
        AutomaticInputFailoverSettings: '',
        InputAttachmentName: '',
        InputId: '',
        InputSettings: ''
      }
    ],
    inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
    logLevel: '',
    maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartTime: ''},
    name: '',
    roleArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/channels/:channelId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cdiInputSpecification":{"Resolution":""},"destinations":[{"Id":"","MediaPackageSettings":"","MultiplexSettings":"","Settings":""}],"encoderSettings":{"AudioDescriptions":"","AvailBlanking":"","AvailConfiguration":"","BlackoutSlate":"","CaptionDescriptions":"","FeatureActivations":"","GlobalConfiguration":"","MotionGraphicsConfiguration":"","NielsenConfiguration":"","OutputGroups":"","TimecodeConfig":"","VideoDescriptions":""},"inputAttachments":[{"AutomaticInputFailoverSettings":"","InputAttachmentName":"","InputId":"","InputSettings":""}],"inputSpecification":{"Codec":"","MaximumBitrate":"","Resolution":""},"logLevel":"","maintenance":{"MaintenanceDay":"","MaintenanceScheduledDate":"","MaintenanceStartTime":""},"name":"","roleArn":""}'
};

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}}/prod/channels/:channelId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cdiInputSpecification": {\n    "Resolution": ""\n  },\n  "destinations": [\n    {\n      "Id": "",\n      "MediaPackageSettings": "",\n      "MultiplexSettings": "",\n      "Settings": ""\n    }\n  ],\n  "encoderSettings": {\n    "AudioDescriptions": "",\n    "AvailBlanking": "",\n    "AvailConfiguration": "",\n    "BlackoutSlate": "",\n    "CaptionDescriptions": "",\n    "FeatureActivations": "",\n    "GlobalConfiguration": "",\n    "MotionGraphicsConfiguration": "",\n    "NielsenConfiguration": "",\n    "OutputGroups": "",\n    "TimecodeConfig": "",\n    "VideoDescriptions": ""\n  },\n  "inputAttachments": [\n    {\n      "AutomaticInputFailoverSettings": "",\n      "InputAttachmentName": "",\n      "InputId": "",\n      "InputSettings": ""\n    }\n  ],\n  "inputSpecification": {\n    "Codec": "",\n    "MaximumBitrate": "",\n    "Resolution": ""\n  },\n  "logLevel": "",\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceScheduledDate": "",\n    "MaintenanceStartTime": ""\n  },\n  "name": "",\n  "roleArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId")
  .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/prod/channels/:channelId',
  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({
  cdiInputSpecification: {Resolution: ''},
  destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
  encoderSettings: {
    AudioDescriptions: '',
    AvailBlanking: '',
    AvailConfiguration: '',
    BlackoutSlate: '',
    CaptionDescriptions: '',
    FeatureActivations: '',
    GlobalConfiguration: '',
    MotionGraphicsConfiguration: '',
    NielsenConfiguration: '',
    OutputGroups: '',
    TimecodeConfig: '',
    VideoDescriptions: ''
  },
  inputAttachments: [
    {
      AutomaticInputFailoverSettings: '',
      InputAttachmentName: '',
      InputId: '',
      InputSettings: ''
    }
  ],
  inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
  logLevel: '',
  maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartTime: ''},
  name: '',
  roleArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/channels/:channelId',
  headers: {'content-type': 'application/json'},
  body: {
    cdiInputSpecification: {Resolution: ''},
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
    encoderSettings: {
      AudioDescriptions: '',
      AvailBlanking: '',
      AvailConfiguration: '',
      BlackoutSlate: '',
      CaptionDescriptions: '',
      FeatureActivations: '',
      GlobalConfiguration: '',
      MotionGraphicsConfiguration: '',
      NielsenConfiguration: '',
      OutputGroups: '',
      TimecodeConfig: '',
      VideoDescriptions: ''
    },
    inputAttachments: [
      {
        AutomaticInputFailoverSettings: '',
        InputAttachmentName: '',
        InputId: '',
        InputSettings: ''
      }
    ],
    inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
    logLevel: '',
    maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartTime: ''},
    name: '',
    roleArn: ''
  },
  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}}/prod/channels/:channelId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cdiInputSpecification: {
    Resolution: ''
  },
  destinations: [
    {
      Id: '',
      MediaPackageSettings: '',
      MultiplexSettings: '',
      Settings: ''
    }
  ],
  encoderSettings: {
    AudioDescriptions: '',
    AvailBlanking: '',
    AvailConfiguration: '',
    BlackoutSlate: '',
    CaptionDescriptions: '',
    FeatureActivations: '',
    GlobalConfiguration: '',
    MotionGraphicsConfiguration: '',
    NielsenConfiguration: '',
    OutputGroups: '',
    TimecodeConfig: '',
    VideoDescriptions: ''
  },
  inputAttachments: [
    {
      AutomaticInputFailoverSettings: '',
      InputAttachmentName: '',
      InputId: '',
      InputSettings: ''
    }
  ],
  inputSpecification: {
    Codec: '',
    MaximumBitrate: '',
    Resolution: ''
  },
  logLevel: '',
  maintenance: {
    MaintenanceDay: '',
    MaintenanceScheduledDate: '',
    MaintenanceStartTime: ''
  },
  name: '',
  roleArn: ''
});

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}}/prod/channels/:channelId',
  headers: {'content-type': 'application/json'},
  data: {
    cdiInputSpecification: {Resolution: ''},
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}],
    encoderSettings: {
      AudioDescriptions: '',
      AvailBlanking: '',
      AvailConfiguration: '',
      BlackoutSlate: '',
      CaptionDescriptions: '',
      FeatureActivations: '',
      GlobalConfiguration: '',
      MotionGraphicsConfiguration: '',
      NielsenConfiguration: '',
      OutputGroups: '',
      TimecodeConfig: '',
      VideoDescriptions: ''
    },
    inputAttachments: [
      {
        AutomaticInputFailoverSettings: '',
        InputAttachmentName: '',
        InputId: '',
        InputSettings: ''
      }
    ],
    inputSpecification: {Codec: '', MaximumBitrate: '', Resolution: ''},
    logLevel: '',
    maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartTime: ''},
    name: '',
    roleArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/channels/:channelId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cdiInputSpecification":{"Resolution":""},"destinations":[{"Id":"","MediaPackageSettings":"","MultiplexSettings":"","Settings":""}],"encoderSettings":{"AudioDescriptions":"","AvailBlanking":"","AvailConfiguration":"","BlackoutSlate":"","CaptionDescriptions":"","FeatureActivations":"","GlobalConfiguration":"","MotionGraphicsConfiguration":"","NielsenConfiguration":"","OutputGroups":"","TimecodeConfig":"","VideoDescriptions":""},"inputAttachments":[{"AutomaticInputFailoverSettings":"","InputAttachmentName":"","InputId":"","InputSettings":""}],"inputSpecification":{"Codec":"","MaximumBitrate":"","Resolution":""},"logLevel":"","maintenance":{"MaintenanceDay":"","MaintenanceScheduledDate":"","MaintenanceStartTime":""},"name":"","roleArn":""}'
};

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 = @{ @"cdiInputSpecification": @{ @"Resolution": @"" },
                              @"destinations": @[ @{ @"Id": @"", @"MediaPackageSettings": @"", @"MultiplexSettings": @"", @"Settings": @"" } ],
                              @"encoderSettings": @{ @"AudioDescriptions": @"", @"AvailBlanking": @"", @"AvailConfiguration": @"", @"BlackoutSlate": @"", @"CaptionDescriptions": @"", @"FeatureActivations": @"", @"GlobalConfiguration": @"", @"MotionGraphicsConfiguration": @"", @"NielsenConfiguration": @"", @"OutputGroups": @"", @"TimecodeConfig": @"", @"VideoDescriptions": @"" },
                              @"inputAttachments": @[ @{ @"AutomaticInputFailoverSettings": @"", @"InputAttachmentName": @"", @"InputId": @"", @"InputSettings": @"" } ],
                              @"inputSpecification": @{ @"Codec": @"", @"MaximumBitrate": @"", @"Resolution": @"" },
                              @"logLevel": @"",
                              @"maintenance": @{ @"MaintenanceDay": @"", @"MaintenanceScheduledDate": @"", @"MaintenanceStartTime": @"" },
                              @"name": @"",
                              @"roleArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/channels/:channelId"]
                                                       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}}/prod/channels/:channelId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/channels/:channelId",
  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([
    'cdiInputSpecification' => [
        'Resolution' => ''
    ],
    'destinations' => [
        [
                'Id' => '',
                'MediaPackageSettings' => '',
                'MultiplexSettings' => '',
                'Settings' => ''
        ]
    ],
    'encoderSettings' => [
        'AudioDescriptions' => '',
        'AvailBlanking' => '',
        'AvailConfiguration' => '',
        'BlackoutSlate' => '',
        'CaptionDescriptions' => '',
        'FeatureActivations' => '',
        'GlobalConfiguration' => '',
        'MotionGraphicsConfiguration' => '',
        'NielsenConfiguration' => '',
        'OutputGroups' => '',
        'TimecodeConfig' => '',
        'VideoDescriptions' => ''
    ],
    'inputAttachments' => [
        [
                'AutomaticInputFailoverSettings' => '',
                'InputAttachmentName' => '',
                'InputId' => '',
                'InputSettings' => ''
        ]
    ],
    'inputSpecification' => [
        'Codec' => '',
        'MaximumBitrate' => '',
        'Resolution' => ''
    ],
    'logLevel' => '',
    'maintenance' => [
        'MaintenanceDay' => '',
        'MaintenanceScheduledDate' => '',
        'MaintenanceStartTime' => ''
    ],
    'name' => '',
    'roleArn' => ''
  ]),
  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}}/prod/channels/:channelId', [
  'body' => '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cdiInputSpecification' => [
    'Resolution' => ''
  ],
  'destinations' => [
    [
        'Id' => '',
        'MediaPackageSettings' => '',
        'MultiplexSettings' => '',
        'Settings' => ''
    ]
  ],
  'encoderSettings' => [
    'AudioDescriptions' => '',
    'AvailBlanking' => '',
    'AvailConfiguration' => '',
    'BlackoutSlate' => '',
    'CaptionDescriptions' => '',
    'FeatureActivations' => '',
    'GlobalConfiguration' => '',
    'MotionGraphicsConfiguration' => '',
    'NielsenConfiguration' => '',
    'OutputGroups' => '',
    'TimecodeConfig' => '',
    'VideoDescriptions' => ''
  ],
  'inputAttachments' => [
    [
        'AutomaticInputFailoverSettings' => '',
        'InputAttachmentName' => '',
        'InputId' => '',
        'InputSettings' => ''
    ]
  ],
  'inputSpecification' => [
    'Codec' => '',
    'MaximumBitrate' => '',
    'Resolution' => ''
  ],
  'logLevel' => '',
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceScheduledDate' => '',
    'MaintenanceStartTime' => ''
  ],
  'name' => '',
  'roleArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cdiInputSpecification' => [
    'Resolution' => ''
  ],
  'destinations' => [
    [
        'Id' => '',
        'MediaPackageSettings' => '',
        'MultiplexSettings' => '',
        'Settings' => ''
    ]
  ],
  'encoderSettings' => [
    'AudioDescriptions' => '',
    'AvailBlanking' => '',
    'AvailConfiguration' => '',
    'BlackoutSlate' => '',
    'CaptionDescriptions' => '',
    'FeatureActivations' => '',
    'GlobalConfiguration' => '',
    'MotionGraphicsConfiguration' => '',
    'NielsenConfiguration' => '',
    'OutputGroups' => '',
    'TimecodeConfig' => '',
    'VideoDescriptions' => ''
  ],
  'inputAttachments' => [
    [
        'AutomaticInputFailoverSettings' => '',
        'InputAttachmentName' => '',
        'InputId' => '',
        'InputSettings' => ''
    ]
  ],
  'inputSpecification' => [
    'Codec' => '',
    'MaximumBitrate' => '',
    'Resolution' => ''
  ],
  'logLevel' => '',
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceScheduledDate' => '',
    'MaintenanceStartTime' => ''
  ],
  'name' => '',
  'roleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/prod/channels/:channelId');
$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}}/prod/channels/:channelId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/channels/:channelId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/channels/:channelId"

payload = {
    "cdiInputSpecification": { "Resolution": "" },
    "destinations": [
        {
            "Id": "",
            "MediaPackageSettings": "",
            "MultiplexSettings": "",
            "Settings": ""
        }
    ],
    "encoderSettings": {
        "AudioDescriptions": "",
        "AvailBlanking": "",
        "AvailConfiguration": "",
        "BlackoutSlate": "",
        "CaptionDescriptions": "",
        "FeatureActivations": "",
        "GlobalConfiguration": "",
        "MotionGraphicsConfiguration": "",
        "NielsenConfiguration": "",
        "OutputGroups": "",
        "TimecodeConfig": "",
        "VideoDescriptions": ""
    },
    "inputAttachments": [
        {
            "AutomaticInputFailoverSettings": "",
            "InputAttachmentName": "",
            "InputId": "",
            "InputSettings": ""
        }
    ],
    "inputSpecification": {
        "Codec": "",
        "MaximumBitrate": "",
        "Resolution": ""
    },
    "logLevel": "",
    "maintenance": {
        "MaintenanceDay": "",
        "MaintenanceScheduledDate": "",
        "MaintenanceStartTime": ""
    },
    "name": "",
    "roleArn": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId"

payload <- "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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}}/prod/channels/:channelId")

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  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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/prod/channels/:channelId') do |req|
  req.body = "{\n  \"cdiInputSpecification\": {\n    \"Resolution\": \"\"\n  },\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ],\n  \"encoderSettings\": {\n    \"AudioDescriptions\": \"\",\n    \"AvailBlanking\": \"\",\n    \"AvailConfiguration\": \"\",\n    \"BlackoutSlate\": \"\",\n    \"CaptionDescriptions\": \"\",\n    \"FeatureActivations\": \"\",\n    \"GlobalConfiguration\": \"\",\n    \"MotionGraphicsConfiguration\": \"\",\n    \"NielsenConfiguration\": \"\",\n    \"OutputGroups\": \"\",\n    \"TimecodeConfig\": \"\",\n    \"VideoDescriptions\": \"\"\n  },\n  \"inputAttachments\": [\n    {\n      \"AutomaticInputFailoverSettings\": \"\",\n      \"InputAttachmentName\": \"\",\n      \"InputId\": \"\",\n      \"InputSettings\": \"\"\n    }\n  ],\n  \"inputSpecification\": {\n    \"Codec\": \"\",\n    \"MaximumBitrate\": \"\",\n    \"Resolution\": \"\"\n  },\n  \"logLevel\": \"\",\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartTime\": \"\"\n  },\n  \"name\": \"\",\n  \"roleArn\": \"\"\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}}/prod/channels/:channelId";

    let payload = json!({
        "cdiInputSpecification": json!({"Resolution": ""}),
        "destinations": (
            json!({
                "Id": "",
                "MediaPackageSettings": "",
                "MultiplexSettings": "",
                "Settings": ""
            })
        ),
        "encoderSettings": json!({
            "AudioDescriptions": "",
            "AvailBlanking": "",
            "AvailConfiguration": "",
            "BlackoutSlate": "",
            "CaptionDescriptions": "",
            "FeatureActivations": "",
            "GlobalConfiguration": "",
            "MotionGraphicsConfiguration": "",
            "NielsenConfiguration": "",
            "OutputGroups": "",
            "TimecodeConfig": "",
            "VideoDescriptions": ""
        }),
        "inputAttachments": (
            json!({
                "AutomaticInputFailoverSettings": "",
                "InputAttachmentName": "",
                "InputId": "",
                "InputSettings": ""
            })
        ),
        "inputSpecification": json!({
            "Codec": "",
            "MaximumBitrate": "",
            "Resolution": ""
        }),
        "logLevel": "",
        "maintenance": json!({
            "MaintenanceDay": "",
            "MaintenanceScheduledDate": "",
            "MaintenanceStartTime": ""
        }),
        "name": "",
        "roleArn": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/channels/:channelId \
  --header 'content-type: application/json' \
  --data '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}'

echo '{
  "cdiInputSpecification": {
    "Resolution": ""
  },
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ],
  "encoderSettings": {
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  },
  "inputAttachments": [
    {
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    }
  ],
  "inputSpecification": {
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  },
  "logLevel": "",
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  },
  "name": "",
  "roleArn": ""
}' |  \
  http PUT {{baseUrl}}/prod/channels/:channelId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "cdiInputSpecification": {\n    "Resolution": ""\n  },\n  "destinations": [\n    {\n      "Id": "",\n      "MediaPackageSettings": "",\n      "MultiplexSettings": "",\n      "Settings": ""\n    }\n  ],\n  "encoderSettings": {\n    "AudioDescriptions": "",\n    "AvailBlanking": "",\n    "AvailConfiguration": "",\n    "BlackoutSlate": "",\n    "CaptionDescriptions": "",\n    "FeatureActivations": "",\n    "GlobalConfiguration": "",\n    "MotionGraphicsConfiguration": "",\n    "NielsenConfiguration": "",\n    "OutputGroups": "",\n    "TimecodeConfig": "",\n    "VideoDescriptions": ""\n  },\n  "inputAttachments": [\n    {\n      "AutomaticInputFailoverSettings": "",\n      "InputAttachmentName": "",\n      "InputId": "",\n      "InputSettings": ""\n    }\n  ],\n  "inputSpecification": {\n    "Codec": "",\n    "MaximumBitrate": "",\n    "Resolution": ""\n  },\n  "logLevel": "",\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceScheduledDate": "",\n    "MaintenanceStartTime": ""\n  },\n  "name": "",\n  "roleArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cdiInputSpecification": ["Resolution": ""],
  "destinations": [
    [
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    ]
  ],
  "encoderSettings": [
    "AudioDescriptions": "",
    "AvailBlanking": "",
    "AvailConfiguration": "",
    "BlackoutSlate": "",
    "CaptionDescriptions": "",
    "FeatureActivations": "",
    "GlobalConfiguration": "",
    "MotionGraphicsConfiguration": "",
    "NielsenConfiguration": "",
    "OutputGroups": "",
    "TimecodeConfig": "",
    "VideoDescriptions": ""
  ],
  "inputAttachments": [
    [
      "AutomaticInputFailoverSettings": "",
      "InputAttachmentName": "",
      "InputId": "",
      "InputSettings": ""
    ]
  ],
  "inputSpecification": [
    "Codec": "",
    "MaximumBitrate": "",
    "Resolution": ""
  ],
  "logLevel": "",
  "maintenance": [
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartTime": ""
  ],
  "name": "",
  "roleArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/channels/:channelId")! 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()

PUT UpdateChannelClass

{{baseUrl}}/prod/channels/:channelId/channelClass

QUERY PARAMS

channelId

BODY json

{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/channels/:channelId/channelClass");

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  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/channels/:channelId/channelClass" {:content-type :json
                                                                                 :form-params {:channelClass ""
                                                                                               :destinations [{:Id ""
                                                                                                               :MediaPackageSettings ""
                                                                                                               :MultiplexSettings ""
                                                                                                               :Settings ""}]}})

require "http/client"

url = "{{baseUrl}}/prod/channels/:channelId/channelClass"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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}}/prod/channels/:channelId/channelClass"),
    Content = new StringContent("{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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}}/prod/channels/:channelId/channelClass");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/channels/:channelId/channelClass"

	payload := strings.NewReader("{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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/prod/channels/:channelId/channelClass HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 163

{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/channels/:channelId/channelClass")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/channels/:channelId/channelClass"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/channelClass")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/channels/:channelId/channelClass")
  .header("content-type", "application/json")
  .body("{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  channelClass: '',
  destinations: [
    {
      Id: '',
      MediaPackageSettings: '',
      MultiplexSettings: '',
      Settings: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/channels/:channelId/channelClass');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/channels/:channelId/channelClass',
  headers: {'content-type': 'application/json'},
  data: {
    channelClass: '',
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/channels/:channelId/channelClass';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"channelClass":"","destinations":[{"Id":"","MediaPackageSettings":"","MultiplexSettings":"","Settings":""}]}'
};

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}}/prod/channels/:channelId/channelClass',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "channelClass": "",\n  "destinations": [\n    {\n      "Id": "",\n      "MediaPackageSettings": "",\n      "MultiplexSettings": "",\n      "Settings": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/channels/:channelId/channelClass")
  .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/prod/channels/:channelId/channelClass',
  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({
  channelClass: '',
  destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/channels/:channelId/channelClass',
  headers: {'content-type': 'application/json'},
  body: {
    channelClass: '',
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}]
  },
  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}}/prod/channels/:channelId/channelClass');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  channelClass: '',
  destinations: [
    {
      Id: '',
      MediaPackageSettings: '',
      MultiplexSettings: '',
      Settings: ''
    }
  ]
});

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}}/prod/channels/:channelId/channelClass',
  headers: {'content-type': 'application/json'},
  data: {
    channelClass: '',
    destinations: [{Id: '', MediaPackageSettings: '', MultiplexSettings: '', Settings: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/channels/:channelId/channelClass';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"channelClass":"","destinations":[{"Id":"","MediaPackageSettings":"","MultiplexSettings":"","Settings":""}]}'
};

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 = @{ @"channelClass": @"",
                              @"destinations": @[ @{ @"Id": @"", @"MediaPackageSettings": @"", @"MultiplexSettings": @"", @"Settings": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/channels/:channelId/channelClass"]
                                                       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}}/prod/channels/:channelId/channelClass" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/channels/:channelId/channelClass",
  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([
    'channelClass' => '',
    'destinations' => [
        [
                'Id' => '',
                'MediaPackageSettings' => '',
                'MultiplexSettings' => '',
                'Settings' => ''
        ]
    ]
  ]),
  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}}/prod/channels/:channelId/channelClass', [
  'body' => '{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/channels/:channelId/channelClass');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'channelClass' => '',
  'destinations' => [
    [
        'Id' => '',
        'MediaPackageSettings' => '',
        'MultiplexSettings' => '',
        'Settings' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'channelClass' => '',
  'destinations' => [
    [
        'Id' => '',
        'MediaPackageSettings' => '',
        'MultiplexSettings' => '',
        'Settings' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/channels/:channelId/channelClass');
$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}}/prod/channels/:channelId/channelClass' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/channels/:channelId/channelClass' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/channels/:channelId/channelClass", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/channels/:channelId/channelClass"

payload = {
    "channelClass": "",
    "destinations": [
        {
            "Id": "",
            "MediaPackageSettings": "",
            "MultiplexSettings": "",
            "Settings": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/channels/:channelId/channelClass"

payload <- "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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}}/prod/channels/:channelId/channelClass")

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  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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/prod/channels/:channelId/channelClass') do |req|
  req.body = "{\n  \"channelClass\": \"\",\n  \"destinations\": [\n    {\n      \"Id\": \"\",\n      \"MediaPackageSettings\": \"\",\n      \"MultiplexSettings\": \"\",\n      \"Settings\": \"\"\n    }\n  ]\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}}/prod/channels/:channelId/channelClass";

    let payload = json!({
        "channelClass": "",
        "destinations": (
            json!({
                "Id": "",
                "MediaPackageSettings": "",
                "MultiplexSettings": "",
                "Settings": ""
            })
        )
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/channels/:channelId/channelClass \
  --header 'content-type: application/json' \
  --data '{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}'

echo '{
  "channelClass": "",
  "destinations": [
    {
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/prod/channels/:channelId/channelClass \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "channelClass": "",\n  "destinations": [\n    {\n      "Id": "",\n      "MediaPackageSettings": "",\n      "MultiplexSettings": "",\n      "Settings": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/prod/channels/:channelId/channelClass

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "channelClass": "",
  "destinations": [
    [
      "Id": "",
      "MediaPackageSettings": "",
      "MultiplexSettings": "",
      "Settings": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/channels/:channelId/channelClass")! 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()

PUT UpdateInput

{{baseUrl}}/prod/inputs/:inputId

QUERY PARAMS

inputId

BODY json

{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputs/:inputId");

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  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/inputs/:inputId" {:content-type :json
                                                                :form-params {:destinations [{:StreamName ""}]
                                                                              :inputDevices [{:Id ""}]
                                                                              :inputSecurityGroups []
                                                                              :mediaConnectFlows [{:FlowArn ""}]
                                                                              :name ""
                                                                              :roleArn ""
                                                                              :sources [{:PasswordParam ""
                                                                                         :Url ""
                                                                                         :Username ""}]}})

require "http/client"

url = "{{baseUrl}}/prod/inputs/:inputId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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}}/prod/inputs/:inputId"),
    Content = new StringContent("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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}}/prod/inputs/:inputId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputs/:inputId"

	payload := strings.NewReader("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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/prod/inputs/:inputId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/inputs/:inputId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputs/:inputId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputs/:inputId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/inputs/:inputId")
  .header("content-type", "application/json")
  .body("{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  destinations: [
    {
      StreamName: ''
    }
  ],
  inputDevices: [
    {
      Id: ''
    }
  ],
  inputSecurityGroups: [],
  mediaConnectFlows: [
    {
      FlowArn: ''
    }
  ],
  name: '',
  roleArn: '',
  sources: [
    {
      PasswordParam: '',
      Url: '',
      Username: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/inputs/:inputId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/inputs/:inputId',
  headers: {'content-type': 'application/json'},
  data: {
    destinations: [{StreamName: ''}],
    inputDevices: [{Id: ''}],
    inputSecurityGroups: [],
    mediaConnectFlows: [{FlowArn: ''}],
    name: '',
    roleArn: '',
    sources: [{PasswordParam: '', Url: '', Username: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputs/:inputId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"destinations":[{"StreamName":""}],"inputDevices":[{"Id":""}],"inputSecurityGroups":[],"mediaConnectFlows":[{"FlowArn":""}],"name":"","roleArn":"","sources":[{"PasswordParam":"","Url":"","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}}/prod/inputs/:inputId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "destinations": [\n    {\n      "StreamName": ""\n    }\n  ],\n  "inputDevices": [\n    {\n      "Id": ""\n    }\n  ],\n  "inputSecurityGroups": [],\n  "mediaConnectFlows": [\n    {\n      "FlowArn": ""\n    }\n  ],\n  "name": "",\n  "roleArn": "",\n  "sources": [\n    {\n      "PasswordParam": "",\n      "Url": "",\n      "Username": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputs/:inputId")
  .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/prod/inputs/:inputId',
  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({
  destinations: [{StreamName: ''}],
  inputDevices: [{Id: ''}],
  inputSecurityGroups: [],
  mediaConnectFlows: [{FlowArn: ''}],
  name: '',
  roleArn: '',
  sources: [{PasswordParam: '', Url: '', Username: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/inputs/:inputId',
  headers: {'content-type': 'application/json'},
  body: {
    destinations: [{StreamName: ''}],
    inputDevices: [{Id: ''}],
    inputSecurityGroups: [],
    mediaConnectFlows: [{FlowArn: ''}],
    name: '',
    roleArn: '',
    sources: [{PasswordParam: '', Url: '', 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('PUT', '{{baseUrl}}/prod/inputs/:inputId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  destinations: [
    {
      StreamName: ''
    }
  ],
  inputDevices: [
    {
      Id: ''
    }
  ],
  inputSecurityGroups: [],
  mediaConnectFlows: [
    {
      FlowArn: ''
    }
  ],
  name: '',
  roleArn: '',
  sources: [
    {
      PasswordParam: '',
      Url: '',
      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: 'PUT',
  url: '{{baseUrl}}/prod/inputs/:inputId',
  headers: {'content-type': 'application/json'},
  data: {
    destinations: [{StreamName: ''}],
    inputDevices: [{Id: ''}],
    inputSecurityGroups: [],
    mediaConnectFlows: [{FlowArn: ''}],
    name: '',
    roleArn: '',
    sources: [{PasswordParam: '', Url: '', Username: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputs/:inputId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"destinations":[{"StreamName":""}],"inputDevices":[{"Id":""}],"inputSecurityGroups":[],"mediaConnectFlows":[{"FlowArn":""}],"name":"","roleArn":"","sources":[{"PasswordParam":"","Url":"","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 = @{ @"destinations": @[ @{ @"StreamName": @"" } ],
                              @"inputDevices": @[ @{ @"Id": @"" } ],
                              @"inputSecurityGroups": @[  ],
                              @"mediaConnectFlows": @[ @{ @"FlowArn": @"" } ],
                              @"name": @"",
                              @"roleArn": @"",
                              @"sources": @[ @{ @"PasswordParam": @"", @"Url": @"", @"Username": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputs/:inputId"]
                                                       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}}/prod/inputs/:inputId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputs/:inputId",
  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([
    'destinations' => [
        [
                'StreamName' => ''
        ]
    ],
    'inputDevices' => [
        [
                'Id' => ''
        ]
    ],
    'inputSecurityGroups' => [
        
    ],
    'mediaConnectFlows' => [
        [
                'FlowArn' => ''
        ]
    ],
    'name' => '',
    'roleArn' => '',
    'sources' => [
        [
                'PasswordParam' => '',
                'Url' => '',
                '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('PUT', '{{baseUrl}}/prod/inputs/:inputId', [
  'body' => '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputs/:inputId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'destinations' => [
    [
        'StreamName' => ''
    ]
  ],
  'inputDevices' => [
    [
        'Id' => ''
    ]
  ],
  'inputSecurityGroups' => [
    
  ],
  'mediaConnectFlows' => [
    [
        'FlowArn' => ''
    ]
  ],
  'name' => '',
  'roleArn' => '',
  'sources' => [
    [
        'PasswordParam' => '',
        'Url' => '',
        'Username' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'destinations' => [
    [
        'StreamName' => ''
    ]
  ],
  'inputDevices' => [
    [
        'Id' => ''
    ]
  ],
  'inputSecurityGroups' => [
    
  ],
  'mediaConnectFlows' => [
    [
        'FlowArn' => ''
    ]
  ],
  'name' => '',
  'roleArn' => '',
  'sources' => [
    [
        'PasswordParam' => '',
        'Url' => '',
        'Username' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputs/:inputId');
$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}}/prod/inputs/:inputId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputs/:inputId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/inputs/:inputId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputs/:inputId"

payload = {
    "destinations": [{ "StreamName": "" }],
    "inputDevices": [{ "Id": "" }],
    "inputSecurityGroups": [],
    "mediaConnectFlows": [{ "FlowArn": "" }],
    "name": "",
    "roleArn": "",
    "sources": [
        {
            "PasswordParam": "",
            "Url": "",
            "Username": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputs/:inputId"

payload <- "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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}}/prod/inputs/:inputId")

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  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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/prod/inputs/:inputId') do |req|
  req.body = "{\n  \"destinations\": [\n    {\n      \"StreamName\": \"\"\n    }\n  ],\n  \"inputDevices\": [\n    {\n      \"Id\": \"\"\n    }\n  ],\n  \"inputSecurityGroups\": [],\n  \"mediaConnectFlows\": [\n    {\n      \"FlowArn\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"roleArn\": \"\",\n  \"sources\": [\n    {\n      \"PasswordParam\": \"\",\n      \"Url\": \"\",\n      \"Username\": \"\"\n    }\n  ]\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}}/prod/inputs/:inputId";

    let payload = json!({
        "destinations": (json!({"StreamName": ""})),
        "inputDevices": (json!({"Id": ""})),
        "inputSecurityGroups": (),
        "mediaConnectFlows": (json!({"FlowArn": ""})),
        "name": "",
        "roleArn": "",
        "sources": (
            json!({
                "PasswordParam": "",
                "Url": "",
                "Username": ""
            })
        )
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/inputs/:inputId \
  --header 'content-type: application/json' \
  --data '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}'

echo '{
  "destinations": [
    {
      "StreamName": ""
    }
  ],
  "inputDevices": [
    {
      "Id": ""
    }
  ],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [
    {
      "FlowArn": ""
    }
  ],
  "name": "",
  "roleArn": "",
  "sources": [
    {
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/prod/inputs/:inputId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "destinations": [\n    {\n      "StreamName": ""\n    }\n  ],\n  "inputDevices": [\n    {\n      "Id": ""\n    }\n  ],\n  "inputSecurityGroups": [],\n  "mediaConnectFlows": [\n    {\n      "FlowArn": ""\n    }\n  ],\n  "name": "",\n  "roleArn": "",\n  "sources": [\n    {\n      "PasswordParam": "",\n      "Url": "",\n      "Username": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputs/:inputId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "destinations": [["StreamName": ""]],
  "inputDevices": [["Id": ""]],
  "inputSecurityGroups": [],
  "mediaConnectFlows": [["FlowArn": ""]],
  "name": "",
  "roleArn": "",
  "sources": [
    [
      "PasswordParam": "",
      "Url": "",
      "Username": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputs/:inputId")! 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()

PUT UpdateInputDevice

{{baseUrl}}/prod/inputDevices/:inputDeviceId

QUERY PARAMS

inputDeviceId

BODY json

{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputDevices/:inputDeviceId");

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  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/inputDevices/:inputDeviceId" {:content-type :json
                                                                            :form-params {:hdDeviceSettings {:ConfiguredInput ""
                                                                                                             :MaxBitrate ""
                                                                                                             :LatencyMs ""}
                                                                                          :name ""
                                                                                          :uhdDeviceSettings {:ConfiguredInput ""
                                                                                                              :MaxBitrate ""
                                                                                                              :LatencyMs ""}}})

require "http/client"

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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}}/prod/inputDevices/:inputDeviceId"),
    Content = new StringContent("{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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}}/prod/inputDevices/:inputDeviceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

	payload := strings.NewReader("{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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/prod/inputDevices/:inputDeviceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 213

{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/inputDevices/:inputDeviceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputDevices/:inputDeviceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/inputDevices/:inputDeviceId")
  .header("content-type", "application/json")
  .body("{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  hdDeviceSettings: {
    ConfiguredInput: '',
    MaxBitrate: '',
    LatencyMs: ''
  },
  name: '',
  uhdDeviceSettings: {
    ConfiguredInput: '',
    MaxBitrate: '',
    LatencyMs: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/inputDevices/:inputDeviceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId',
  headers: {'content-type': 'application/json'},
  data: {
    hdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''},
    name: '',
    uhdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"hdDeviceSettings":{"ConfiguredInput":"","MaxBitrate":"","LatencyMs":""},"name":"","uhdDeviceSettings":{"ConfiguredInput":"","MaxBitrate":"","LatencyMs":""}}'
};

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}}/prod/inputDevices/:inputDeviceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "hdDeviceSettings": {\n    "ConfiguredInput": "",\n    "MaxBitrate": "",\n    "LatencyMs": ""\n  },\n  "name": "",\n  "uhdDeviceSettings": {\n    "ConfiguredInput": "",\n    "MaxBitrate": "",\n    "LatencyMs": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputDevices/:inputDeviceId")
  .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/prod/inputDevices/:inputDeviceId',
  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({
  hdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''},
  name: '',
  uhdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/inputDevices/:inputDeviceId',
  headers: {'content-type': 'application/json'},
  body: {
    hdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''},
    name: '',
    uhdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''}
  },
  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}}/prod/inputDevices/:inputDeviceId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  hdDeviceSettings: {
    ConfiguredInput: '',
    MaxBitrate: '',
    LatencyMs: ''
  },
  name: '',
  uhdDeviceSettings: {
    ConfiguredInput: '',
    MaxBitrate: '',
    LatencyMs: ''
  }
});

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}}/prod/inputDevices/:inputDeviceId',
  headers: {'content-type': 'application/json'},
  data: {
    hdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''},
    name: '',
    uhdDeviceSettings: {ConfiguredInput: '', MaxBitrate: '', LatencyMs: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputDevices/:inputDeviceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"hdDeviceSettings":{"ConfiguredInput":"","MaxBitrate":"","LatencyMs":""},"name":"","uhdDeviceSettings":{"ConfiguredInput":"","MaxBitrate":"","LatencyMs":""}}'
};

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 = @{ @"hdDeviceSettings": @{ @"ConfiguredInput": @"", @"MaxBitrate": @"", @"LatencyMs": @"" },
                              @"name": @"",
                              @"uhdDeviceSettings": @{ @"ConfiguredInput": @"", @"MaxBitrate": @"", @"LatencyMs": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputDevices/:inputDeviceId"]
                                                       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}}/prod/inputDevices/:inputDeviceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputDevices/:inputDeviceId",
  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([
    'hdDeviceSettings' => [
        'ConfiguredInput' => '',
        'MaxBitrate' => '',
        'LatencyMs' => ''
    ],
    'name' => '',
    'uhdDeviceSettings' => [
        'ConfiguredInput' => '',
        'MaxBitrate' => '',
        'LatencyMs' => ''
    ]
  ]),
  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}}/prod/inputDevices/:inputDeviceId', [
  'body' => '{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'hdDeviceSettings' => [
    'ConfiguredInput' => '',
    'MaxBitrate' => '',
    'LatencyMs' => ''
  ],
  'name' => '',
  'uhdDeviceSettings' => [
    'ConfiguredInput' => '',
    'MaxBitrate' => '',
    'LatencyMs' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'hdDeviceSettings' => [
    'ConfiguredInput' => '',
    'MaxBitrate' => '',
    'LatencyMs' => ''
  ],
  'name' => '',
  'uhdDeviceSettings' => [
    'ConfiguredInput' => '',
    'MaxBitrate' => '',
    'LatencyMs' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputDevices/:inputDeviceId');
$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}}/prod/inputDevices/:inputDeviceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputDevices/:inputDeviceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/inputDevices/:inputDeviceId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

payload = {
    "hdDeviceSettings": {
        "ConfiguredInput": "",
        "MaxBitrate": "",
        "LatencyMs": ""
    },
    "name": "",
    "uhdDeviceSettings": {
        "ConfiguredInput": "",
        "MaxBitrate": "",
        "LatencyMs": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputDevices/:inputDeviceId"

payload <- "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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}}/prod/inputDevices/:inputDeviceId")

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  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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/prod/inputDevices/:inputDeviceId') do |req|
  req.body = "{\n  \"hdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  },\n  \"name\": \"\",\n  \"uhdDeviceSettings\": {\n    \"ConfiguredInput\": \"\",\n    \"MaxBitrate\": \"\",\n    \"LatencyMs\": \"\"\n  }\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}}/prod/inputDevices/:inputDeviceId";

    let payload = json!({
        "hdDeviceSettings": json!({
            "ConfiguredInput": "",
            "MaxBitrate": "",
            "LatencyMs": ""
        }),
        "name": "",
        "uhdDeviceSettings": json!({
            "ConfiguredInput": "",
            "MaxBitrate": "",
            "LatencyMs": ""
        })
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/inputDevices/:inputDeviceId \
  --header 'content-type: application/json' \
  --data '{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}'

echo '{
  "hdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  },
  "name": "",
  "uhdDeviceSettings": {
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  }
}' |  \
  http PUT {{baseUrl}}/prod/inputDevices/:inputDeviceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "hdDeviceSettings": {\n    "ConfiguredInput": "",\n    "MaxBitrate": "",\n    "LatencyMs": ""\n  },\n  "name": "",\n  "uhdDeviceSettings": {\n    "ConfiguredInput": "",\n    "MaxBitrate": "",\n    "LatencyMs": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputDevices/:inputDeviceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "hdDeviceSettings": [
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  ],
  "name": "",
  "uhdDeviceSettings": [
    "ConfiguredInput": "",
    "MaxBitrate": "",
    "LatencyMs": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputDevices/:inputDeviceId")! 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()

PUT UpdateInputSecurityGroup

{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

QUERY PARAMS

inputSecurityGroupId

BODY json

{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId");

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  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId" {:content-type :json
                                                                                          :form-params {:tags {}
                                                                                                        :whitelistRules [{:Cidr ""}]}})

require "http/client"

url = "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups/:inputSecurityGroupId"),
    Content = new StringContent("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups/:inputSecurityGroupId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

	payload := strings.NewReader("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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/prod/inputSecurityGroups/:inputSecurityGroupId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  tags: {},
  whitelistRules: [
    {
      Cidr: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId',
  headers: {'content-type': 'application/json'},
  data: {tags: {}, whitelistRules: [{Cidr: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{},"whitelistRules":[{"Cidr":""}]}'
};

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}}/prod/inputSecurityGroups/:inputSecurityGroupId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {},\n  "whitelistRules": [\n    {\n      "Cidr": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")
  .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/prod/inputSecurityGroups/:inputSecurityGroupId',
  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({tags: {}, whitelistRules: [{Cidr: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId',
  headers: {'content-type': 'application/json'},
  body: {tags: {}, whitelistRules: [{Cidr: ''}]},
  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}}/prod/inputSecurityGroups/:inputSecurityGroupId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tags: {},
  whitelistRules: [
    {
      Cidr: ''
    }
  ]
});

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}}/prod/inputSecurityGroups/:inputSecurityGroupId',
  headers: {'content-type': 'application/json'},
  data: {tags: {}, whitelistRules: [{Cidr: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{},"whitelistRules":[{"Cidr":""}]}'
};

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 = @{ @"tags": @{  },
                              @"whitelistRules": @[ @{ @"Cidr": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"]
                                                       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}}/prod/inputSecurityGroups/:inputSecurityGroupId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId",
  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([
    'tags' => [
        
    ],
    'whitelistRules' => [
        [
                'Cidr' => ''
        ]
    ]
  ]),
  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}}/prod/inputSecurityGroups/:inputSecurityGroupId', [
  'body' => '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ],
  'whitelistRules' => [
    [
        'Cidr' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    
  ],
  'whitelistRules' => [
    [
        'Cidr' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId');
$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}}/prod/inputSecurityGroups/:inputSecurityGroupId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/inputSecurityGroups/:inputSecurityGroupId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

payload = {
    "tags": {},
    "whitelistRules": [{ "Cidr": "" }]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId"

payload <- "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups/:inputSecurityGroupId")

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  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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/prod/inputSecurityGroups/:inputSecurityGroupId') do |req|
  req.body = "{\n  \"tags\": {},\n  \"whitelistRules\": [\n    {\n      \"Cidr\": \"\"\n    }\n  ]\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}}/prod/inputSecurityGroups/:inputSecurityGroupId";

    let payload = json!({
        "tags": json!({}),
        "whitelistRules": (json!({"Cidr": ""}))
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId \
  --header 'content-type: application/json' \
  --data '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}'

echo '{
  "tags": {},
  "whitelistRules": [
    {
      "Cidr": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {},\n  "whitelistRules": [\n    {\n      "Cidr": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "tags": [],
  "whitelistRules": [["Cidr": ""]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/inputSecurityGroups/:inputSecurityGroupId")! 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()

PUT UpdateMultiplex

{{baseUrl}}/prod/multiplexes/:multiplexId

QUERY PARAMS

multiplexId

BODY json

{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId");

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  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/multiplexes/:multiplexId" {:content-type :json
                                                                         :form-params {:multiplexSettings {:MaximumVideoBufferDelayMilliseconds ""
                                                                                                           :TransportStreamBitrate ""
                                                                                                           :TransportStreamId ""
                                                                                                           :TransportStreamReservedBitrate ""}
                                                                                       :name ""}})

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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}}/prod/multiplexes/:multiplexId"),
    Content = new StringContent("{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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}}/prod/multiplexes/:multiplexId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId"

	payload := strings.NewReader("{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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/prod/multiplexes/:multiplexId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 197

{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/multiplexes/:multiplexId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/multiplexes/:multiplexId")
  .header("content-type", "application/json")
  .body("{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  multiplexSettings: {
    MaximumVideoBufferDelayMilliseconds: '',
    TransportStreamBitrate: '',
    TransportStreamId: '',
    TransportStreamReservedBitrate: ''
  },
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/multiplexes/:multiplexId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId',
  headers: {'content-type': 'application/json'},
  data: {
    multiplexSettings: {
      MaximumVideoBufferDelayMilliseconds: '',
      TransportStreamBitrate: '',
      TransportStreamId: '',
      TransportStreamReservedBitrate: ''
    },
    name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"multiplexSettings":{"MaximumVideoBufferDelayMilliseconds":"","TransportStreamBitrate":"","TransportStreamId":"","TransportStreamReservedBitrate":""},"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "multiplexSettings": {\n    "MaximumVideoBufferDelayMilliseconds": "",\n    "TransportStreamBitrate": "",\n    "TransportStreamId": "",\n    "TransportStreamReservedBitrate": ""\n  },\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId")
  .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/prod/multiplexes/:multiplexId',
  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({
  multiplexSettings: {
    MaximumVideoBufferDelayMilliseconds: '',
    TransportStreamBitrate: '',
    TransportStreamId: '',
    TransportStreamReservedBitrate: ''
  },
  name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId',
  headers: {'content-type': 'application/json'},
  body: {
    multiplexSettings: {
      MaximumVideoBufferDelayMilliseconds: '',
      TransportStreamBitrate: '',
      TransportStreamId: '',
      TransportStreamReservedBitrate: ''
    },
    name: ''
  },
  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}}/prod/multiplexes/:multiplexId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  multiplexSettings: {
    MaximumVideoBufferDelayMilliseconds: '',
    TransportStreamBitrate: '',
    TransportStreamId: '',
    TransportStreamReservedBitrate: ''
  },
  name: ''
});

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}}/prod/multiplexes/:multiplexId',
  headers: {'content-type': 'application/json'},
  data: {
    multiplexSettings: {
      MaximumVideoBufferDelayMilliseconds: '',
      TransportStreamBitrate: '',
      TransportStreamId: '',
      TransportStreamReservedBitrate: ''
    },
    name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"multiplexSettings":{"MaximumVideoBufferDelayMilliseconds":"","TransportStreamBitrate":"","TransportStreamId":"","TransportStreamReservedBitrate":""},"name":""}'
};

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 = @{ @"multiplexSettings": @{ @"MaximumVideoBufferDelayMilliseconds": @"", @"TransportStreamBitrate": @"", @"TransportStreamId": @"", @"TransportStreamReservedBitrate": @"" },
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/multiplexes/:multiplexId"]
                                                       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}}/prod/multiplexes/:multiplexId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/multiplexes/:multiplexId",
  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([
    'multiplexSettings' => [
        'MaximumVideoBufferDelayMilliseconds' => '',
        'TransportStreamBitrate' => '',
        'TransportStreamId' => '',
        'TransportStreamReservedBitrate' => ''
    ],
    'name' => ''
  ]),
  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}}/prod/multiplexes/:multiplexId', [
  'body' => '{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'multiplexSettings' => [
    'MaximumVideoBufferDelayMilliseconds' => '',
    'TransportStreamBitrate' => '',
    'TransportStreamId' => '',
    'TransportStreamReservedBitrate' => ''
  ],
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'multiplexSettings' => [
    'MaximumVideoBufferDelayMilliseconds' => '',
    'TransportStreamBitrate' => '',
    'TransportStreamId' => '',
    'TransportStreamReservedBitrate' => ''
  ],
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId');
$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}}/prod/multiplexes/:multiplexId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/multiplexes/:multiplexId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId"

payload = {
    "multiplexSettings": {
        "MaximumVideoBufferDelayMilliseconds": "",
        "TransportStreamBitrate": "",
        "TransportStreamId": "",
        "TransportStreamReservedBitrate": ""
    },
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId"

payload <- "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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}}/prod/multiplexes/:multiplexId")

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  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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/prod/multiplexes/:multiplexId') do |req|
  req.body = "{\n  \"multiplexSettings\": {\n    \"MaximumVideoBufferDelayMilliseconds\": \"\",\n    \"TransportStreamBitrate\": \"\",\n    \"TransportStreamId\": \"\",\n    \"TransportStreamReservedBitrate\": \"\"\n  },\n  \"name\": \"\"\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}}/prod/multiplexes/:multiplexId";

    let payload = json!({
        "multiplexSettings": json!({
            "MaximumVideoBufferDelayMilliseconds": "",
            "TransportStreamBitrate": "",
            "TransportStreamId": "",
            "TransportStreamReservedBitrate": ""
        }),
        "name": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId \
  --header 'content-type: application/json' \
  --data '{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}'

echo '{
  "multiplexSettings": {
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  },
  "name": ""
}' |  \
  http PUT {{baseUrl}}/prod/multiplexes/:multiplexId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "multiplexSettings": {\n    "MaximumVideoBufferDelayMilliseconds": "",\n    "TransportStreamBitrate": "",\n    "TransportStreamId": "",\n    "TransportStreamReservedBitrate": ""\n  },\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "multiplexSettings": [
    "MaximumVideoBufferDelayMilliseconds": "",
    "TransportStreamBitrate": "",
    "TransportStreamId": "",
    "TransportStreamReservedBitrate": ""
  ],
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId")! 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()

PUT UpdateMultiplexProgram

{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

QUERY PARAMS

multiplexId

programName

BODY json

{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName");

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  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName" {:content-type :json
                                                                                               :form-params {:multiplexProgramSettings {:PreferredChannelPipeline ""
                                                                                                                                        :ProgramNumber ""
                                                                                                                                        :ServiceDescriptor ""
                                                                                                                                        :VideoSettings ""}}})

require "http/client"

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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}}/prod/multiplexes/:multiplexId/programs/:programName"),
    Content = new StringContent("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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}}/prod/multiplexes/:multiplexId/programs/:programName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

	payload := strings.NewReader("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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/prod/multiplexes/:multiplexId/programs/:programName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .header("content-type", "application/json")
  .body("{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  multiplexProgramSettings: {
    PreferredChannelPipeline: '',
    ProgramNumber: '',
    ServiceDescriptor: '',
    VideoSettings: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName',
  headers: {'content-type': 'application/json'},
  data: {
    multiplexProgramSettings: {
      PreferredChannelPipeline: '',
      ProgramNumber: '',
      ServiceDescriptor: '',
      VideoSettings: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"multiplexProgramSettings":{"PreferredChannelPipeline":"","ProgramNumber":"","ServiceDescriptor":"","VideoSettings":""}}'
};

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}}/prod/multiplexes/:multiplexId/programs/:programName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "multiplexProgramSettings": {\n    "PreferredChannelPipeline": "",\n    "ProgramNumber": "",\n    "ServiceDescriptor": "",\n    "VideoSettings": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")
  .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/prod/multiplexes/:multiplexId/programs/:programName',
  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({
  multiplexProgramSettings: {
    PreferredChannelPipeline: '',
    ProgramNumber: '',
    ServiceDescriptor: '',
    VideoSettings: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName',
  headers: {'content-type': 'application/json'},
  body: {
    multiplexProgramSettings: {
      PreferredChannelPipeline: '',
      ProgramNumber: '',
      ServiceDescriptor: '',
      VideoSettings: ''
    }
  },
  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}}/prod/multiplexes/:multiplexId/programs/:programName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  multiplexProgramSettings: {
    PreferredChannelPipeline: '',
    ProgramNumber: '',
    ServiceDescriptor: '',
    VideoSettings: ''
  }
});

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}}/prod/multiplexes/:multiplexId/programs/:programName',
  headers: {'content-type': 'application/json'},
  data: {
    multiplexProgramSettings: {
      PreferredChannelPipeline: '',
      ProgramNumber: '',
      ServiceDescriptor: '',
      VideoSettings: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"multiplexProgramSettings":{"PreferredChannelPipeline":"","ProgramNumber":"","ServiceDescriptor":"","VideoSettings":""}}'
};

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 = @{ @"multiplexProgramSettings": @{ @"PreferredChannelPipeline": @"", @"ProgramNumber": @"", @"ServiceDescriptor": @"", @"VideoSettings": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"]
                                                       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}}/prod/multiplexes/:multiplexId/programs/:programName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName",
  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([
    'multiplexProgramSettings' => [
        'PreferredChannelPipeline' => '',
        'ProgramNumber' => '',
        'ServiceDescriptor' => '',
        'VideoSettings' => ''
    ]
  ]),
  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}}/prod/multiplexes/:multiplexId/programs/:programName', [
  'body' => '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'multiplexProgramSettings' => [
    'PreferredChannelPipeline' => '',
    'ProgramNumber' => '',
    'ServiceDescriptor' => '',
    'VideoSettings' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'multiplexProgramSettings' => [
    'PreferredChannelPipeline' => '',
    'ProgramNumber' => '',
    'ServiceDescriptor' => '',
    'VideoSettings' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName');
$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}}/prod/multiplexes/:multiplexId/programs/:programName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/multiplexes/:multiplexId/programs/:programName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

payload = { "multiplexProgramSettings": {
        "PreferredChannelPipeline": "",
        "ProgramNumber": "",
        "ServiceDescriptor": "",
        "VideoSettings": ""
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName"

payload <- "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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}}/prod/multiplexes/:multiplexId/programs/:programName")

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  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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/prod/multiplexes/:multiplexId/programs/:programName') do |req|
  req.body = "{\n  \"multiplexProgramSettings\": {\n    \"PreferredChannelPipeline\": \"\",\n    \"ProgramNumber\": \"\",\n    \"ServiceDescriptor\": \"\",\n    \"VideoSettings\": \"\"\n  }\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}}/prod/multiplexes/:multiplexId/programs/:programName";

    let payload = json!({"multiplexProgramSettings": json!({
            "PreferredChannelPipeline": "",
            "ProgramNumber": "",
            "ServiceDescriptor": "",
            "VideoSettings": ""
        })});

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName \
  --header 'content-type: application/json' \
  --data '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}'

echo '{
  "multiplexProgramSettings": {
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  }
}' |  \
  http PUT {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "multiplexProgramSettings": {\n    "PreferredChannelPipeline": "",\n    "ProgramNumber": "",\n    "ServiceDescriptor": "",\n    "VideoSettings": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["multiplexProgramSettings": [
    "PreferredChannelPipeline": "",
    "ProgramNumber": "",
    "ServiceDescriptor": "",
    "VideoSettings": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/multiplexes/:multiplexId/programs/:programName")! 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()

PUT UpdateReservation

{{baseUrl}}/prod/reservations/:reservationId

QUERY PARAMS

reservationId

BODY json

{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/prod/reservations/:reservationId");

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  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/prod/reservations/:reservationId" {:content-type :json
                                                                            :form-params {:name ""
                                                                                          :renewalSettings {:AutomaticRenewal ""
                                                                                                            :RenewalCount ""}}})

require "http/client"

url = "{{baseUrl}}/prod/reservations/:reservationId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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}}/prod/reservations/:reservationId"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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}}/prod/reservations/:reservationId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/prod/reservations/:reservationId"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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/prod/reservations/:reservationId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 95

{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/prod/reservations/:reservationId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/prod/reservations/:reservationId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/prod/reservations/:reservationId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/prod/reservations/:reservationId")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  renewalSettings: {
    AutomaticRenewal: '',
    RenewalCount: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/prod/reservations/:reservationId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/reservations/:reservationId',
  headers: {'content-type': 'application/json'},
  data: {name: '', renewalSettings: {AutomaticRenewal: '', RenewalCount: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/prod/reservations/:reservationId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","renewalSettings":{"AutomaticRenewal":"","RenewalCount":""}}'
};

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}}/prod/reservations/:reservationId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "renewalSettings": {\n    "AutomaticRenewal": "",\n    "RenewalCount": ""\n  }\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  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/prod/reservations/:reservationId")
  .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/prod/reservations/:reservationId',
  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: '', renewalSettings: {AutomaticRenewal: '', RenewalCount: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/prod/reservations/:reservationId',
  headers: {'content-type': 'application/json'},
  body: {name: '', renewalSettings: {AutomaticRenewal: '', RenewalCount: ''}},
  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}}/prod/reservations/:reservationId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  renewalSettings: {
    AutomaticRenewal: '',
    RenewalCount: ''
  }
});

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}}/prod/reservations/:reservationId',
  headers: {'content-type': 'application/json'},
  data: {name: '', renewalSettings: {AutomaticRenewal: '', RenewalCount: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/prod/reservations/:reservationId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","renewalSettings":{"AutomaticRenewal":"","RenewalCount":""}}'
};

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": @"",
                              @"renewalSettings": @{ @"AutomaticRenewal": @"", @"RenewalCount": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/prod/reservations/:reservationId"]
                                                       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}}/prod/reservations/:reservationId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/prod/reservations/:reservationId",
  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' => '',
    'renewalSettings' => [
        'AutomaticRenewal' => '',
        'RenewalCount' => ''
    ]
  ]),
  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}}/prod/reservations/:reservationId', [
  'body' => '{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/prod/reservations/:reservationId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'renewalSettings' => [
    'AutomaticRenewal' => '',
    'RenewalCount' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'renewalSettings' => [
    'AutomaticRenewal' => '',
    'RenewalCount' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/prod/reservations/:reservationId');
$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}}/prod/reservations/:reservationId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/prod/reservations/:reservationId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/prod/reservations/:reservationId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/prod/reservations/:reservationId"

payload = {
    "name": "",
    "renewalSettings": {
        "AutomaticRenewal": "",
        "RenewalCount": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/prod/reservations/:reservationId"

payload <- "{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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}}/prod/reservations/:reservationId")

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  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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/prod/reservations/:reservationId') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"renewalSettings\": {\n    \"AutomaticRenewal\": \"\",\n    \"RenewalCount\": \"\"\n  }\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}}/prod/reservations/:reservationId";

    let payload = json!({
        "name": "",
        "renewalSettings": json!({
            "AutomaticRenewal": "",
            "RenewalCount": ""
        })
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/prod/reservations/:reservationId \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}'

echo '{
  "name": "",
  "renewalSettings": {
    "AutomaticRenewal": "",
    "RenewalCount": ""
  }
}' |  \
  http PUT {{baseUrl}}/prod/reservations/:reservationId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "renewalSettings": {\n    "AutomaticRenewal": "",\n    "RenewalCount": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/prod/reservations/:reservationId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "renewalSettings": [
    "AutomaticRenewal": "",
    "RenewalCount": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/prod/reservations/:reservationId")! 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()