CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/actionBatches");

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  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organizations/:organizationId/actionBatches" {:content-type :json
                                                                                        :form-params {:actions [{:body {}
                                                                                                                 :operation ""
                                                                                                                 :resource ""}]
                                                                                                      :confirmed false
                                                                                                      :synchronous false}})

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/actionBatches"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches"),
    Content = new StringContent("{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/actionBatches"

	payload := strings.NewReader("{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\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/organizations/:organizationId/actionBatches HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 142

{
  "actions": [
    {
      "body": {},
      "operation": "",
      "resource": ""
    }
  ],
  "confirmed": false,
  "synchronous": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organizations/:organizationId/actionBatches")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/actionBatches"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\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  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/actionBatches")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/organizations/:organizationId/actionBatches")
  .header("content-type", "application/json")
  .body("{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}")
  .asString();

const data = JSON.stringify({
  actions: [
    {
      body: {},
      operation: '',
      resource: ''
    }
  ],
  confirmed: false,
  synchronous: false
});

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

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

xhr.open('POST', '{{baseUrl}}/organizations/:organizationId/actionBatches');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches',
  headers: {'content-type': 'application/json'},
  data: {
    actions: [{body: {}, operation: '', resource: ''}],
    confirmed: false,
    synchronous: false
  }
};

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"actions":[{"body":{},"operation":"","resource":""}],"confirmed":false,"synchronous":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "actions": [\n    {\n      "body": {},\n      "operation": "",\n      "resource": ""\n    }\n  ],\n  "confirmed": false,\n  "synchronous": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/actionBatches")
  .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/organizations/:organizationId/actionBatches',
  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({
  actions: [{body: {}, operation: '', resource: ''}],
  confirmed: false,
  synchronous: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches',
  headers: {'content-type': 'application/json'},
  body: {
    actions: [{body: {}, operation: '', resource: ''}],
    confirmed: false,
    synchronous: false
  },
  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}}/organizations/:organizationId/actionBatches');

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

req.type('json');
req.send({
  actions: [
    {
      body: {},
      operation: '',
      resource: ''
    }
  ],
  confirmed: false,
  synchronous: false
});

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}}/organizations/:organizationId/actionBatches',
  headers: {'content-type': 'application/json'},
  data: {
    actions: [{body: {}, operation: '', resource: ''}],
    confirmed: false,
    synchronous: false
  }
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"actions":[{"body":{},"operation":"","resource":""}],"confirmed":false,"synchronous":false}'
};

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 = @{ @"actions": @[ @{ @"body": @{  }, @"operation": @"", @"resource": @"" } ],
                              @"confirmed": @NO,
                              @"synchronous": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/:organizationId/actionBatches"]
                                                       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}}/organizations/:organizationId/actionBatches" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}" in

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

 "{{baseUrl}}/organizations/:organizationId/actionBatches",
  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([
    'actions' => [
        [
                'body' => [
                                
                ],
                'operation' => '',
                'resource' => ''
        ]
    ],
    'confirmed' => null,
    'synchronous' => null
  ]),
  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}}/organizations/:organizationId/actionBatches', [
  'body' => '{
  "actions": [
    {
      "body": {},
      "operation": "",
      "resource": ""
    }
  ],
  "confirmed": false,
  "synchronous": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/actionBatches');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'actions' => [
    [
        'body' => [
                
        ],
        'operation' => '',
        'resource' => ''
    ]
  ],
  'confirmed' => null,
  'synchronous' => null
]));

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

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

append(json_encode([
  'actions' => [
    [
        'body' => [
                
        ],
        'operation' => '',
        'resource' => ''
    ]
  ],
  'confirmed' => null,
  'synchronous' => null
]));
$request->setRequestUrl('{{baseUrl}}/organizations/:organizationId/actionBatches');
$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}}/organizations/:organizationId/actionBatches' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "actions": [
    {
      "body": {},
      "operation": "",
      "resource": ""
    }
  ],
  "confirmed": false,
  "synchronous": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/actionBatches' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "actions": [
    {
      "body": {},
      "operation": "",
      "resource": ""
    }
  ],
  "confirmed": false,
  "synchronous": false
}'

import http.client

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

payload = "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}"

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

conn.request("POST", "/baseUrl/organizations/:organizationId/actionBatches", payload, headers)

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/actionBatches"

payload = {
    "actions": [
        {
            "body": {},
            "operation": "",
            "resource": ""
        }
    ],
    "confirmed": False,
    "synchronous": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/actionBatches"

payload <- "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches")

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  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\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/organizations/:organizationId/actionBatches') do |req|
  req.body = "{\n  \"actions\": [\n    {\n      \"body\": {},\n      \"operation\": \"\",\n      \"resource\": \"\"\n    }\n  ],\n  \"confirmed\": false,\n  \"synchronous\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "actions": (
            json!({
                "body": json!({}),
                "operation": "",
                "resource": ""
            })
        ),
        "confirmed": false,
        "synchronous": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "actions": [
    {
      "body": {},
      "operation": "",
      "resource": ""
    }
  ],
  "confirmed": false,
  "synchronous": false
}' |  \
  http POST {{baseUrl}}/organizations/:organizationId/actionBatches \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "actions": [\n    {\n      "body": {},\n      "operation": "",\n      "resource": ""\n    }\n  ],\n  "confirmed": false,\n  "synchronous": false\n}' \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/actionBatches

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "actions": [
    [
      "body": [],
      "operation": "",
      "resource": ""
    ]
  ],
  "confirmed": false,
  "synchronous": false
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

	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/organizations/:organizationId/actionBatches/:actionBatchId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .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}}/organizations/:organizationId/actionBatches/:actionBatchId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId'
};

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId';
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}}/organizations/:organizationId/actionBatches/:actionBatchId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/organizations/:organizationId/actionBatches/:actionBatchId',
  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}}/organizations/:organizationId/actionBatches/:actionBatchId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId');

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}}/organizations/:organizationId/actionBatches/:actionBatchId'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId';
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}}/organizations/:organizationId/actionBatches/:actionBatchId"]
                                                       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}}/organizations/:organizationId/actionBatches/:actionBatchId" in

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

 "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId",
  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}}/organizations/:organizationId/actionBatches/:actionBatchId');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/organizations/:organizationId/actionBatches/:actionBatchId")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")

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/organizations/:organizationId/actionBatches/:actionBatchId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/actionBatches");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/organizations/:organizationId/actionBatches")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/actionBatches"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/actionBatches");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/actionBatches"

	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/organizations/:organizationId/actionBatches HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/actionBatches")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/organizations/:organizationId/actionBatches');

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}}/organizations/:organizationId/actionBatches'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches';
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}}/organizations/:organizationId/actionBatches"]
                                                       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}}/organizations/:organizationId/actionBatches" in

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

 "{{baseUrl}}/organizations/:organizationId/actionBatches",
  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}}/organizations/:organizationId/actionBatches');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/actionBatches');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/actionBatches');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/actionBatches' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/actionBatches' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/organizations/:organizationId/actionBatches")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/actionBatches"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/actionBatches"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/actionBatches")

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/organizations/:organizationId/actionBatches') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/organizations/:organizationId/actionBatches

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/actionBatches

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId");

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  \"confirmed\": false,\n  \"synchronous\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId" {:content-type :json
                                                                                                      :form-params {:confirmed false
                                                                                                                    :synchronous false}})

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches/:actionBatchId"),
    Content = new StringContent("{\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches/:actionBatchId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"confirmed\": false,\n  \"synchronous\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

	payload := strings.NewReader("{\n  \"confirmed\": false,\n  \"synchronous\": false\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/organizations/:organizationId/actionBatches/:actionBatchId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "confirmed": false,
  "synchronous": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"confirmed\": false,\n  \"synchronous\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"confirmed\": false,\n  \"synchronous\": false\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  \"confirmed\": false,\n  \"synchronous\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .header("content-type", "application/json")
  .body("{\n  \"confirmed\": false,\n  \"synchronous\": false\n}")
  .asString();

const data = JSON.stringify({
  confirmed: false,
  synchronous: false
});

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

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

xhr.open('PUT', '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId',
  headers: {'content-type': 'application/json'},
  data: {confirmed: false, synchronous: false}
};

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"confirmed":false,"synchronous":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "confirmed": false,\n  "synchronous": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"confirmed\": false,\n  \"synchronous\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId")
  .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/organizations/:organizationId/actionBatches/:actionBatchId',
  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({confirmed: false, synchronous: false}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId',
  headers: {'content-type': 'application/json'},
  body: {confirmed: false, synchronous: false},
  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}}/organizations/:organizationId/actionBatches/:actionBatchId');

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

req.type('json');
req.send({
  confirmed: false,
  synchronous: false
});

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}}/organizations/:organizationId/actionBatches/:actionBatchId',
  headers: {'content-type': 'application/json'},
  data: {confirmed: false, synchronous: false}
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"confirmed":false,"synchronous":false}'
};

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 = @{ @"confirmed": @NO,
                              @"synchronous": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"]
                                                       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}}/organizations/:organizationId/actionBatches/:actionBatchId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"confirmed\": false,\n  \"synchronous\": false\n}" in

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

 "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId",
  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([
    'confirmed' => null,
    'synchronous' => null
  ]),
  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}}/organizations/:organizationId/actionBatches/:actionBatchId', [
  'body' => '{
  "confirmed": false,
  "synchronous": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'confirmed' => null,
  'synchronous' => null
]));

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

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

append(json_encode([
  'confirmed' => null,
  'synchronous' => null
]));
$request->setRequestUrl('{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId');
$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}}/organizations/:organizationId/actionBatches/:actionBatchId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "confirmed": false,
  "synchronous": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "confirmed": false,
  "synchronous": false
}'

import http.client

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

payload = "{\n  \"confirmed\": false,\n  \"synchronous\": false\n}"

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

conn.request("PUT", "/baseUrl/organizations/:organizationId/actionBatches/:actionBatchId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

payload = {
    "confirmed": False,
    "synchronous": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId"

payload <- "{\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches/:actionBatchId")

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  \"confirmed\": false,\n  \"synchronous\": false\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/organizations/:organizationId/actionBatches/:actionBatchId') do |req|
  req.body = "{\n  \"confirmed\": false,\n  \"synchronous\": false\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}}/organizations/:organizationId/actionBatches/:actionBatchId";

    let payload = json!({
        "confirmed": false,
        "synchronous": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "confirmed": false,
  "synchronous": false
}' |  \
  http PUT {{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "confirmed": false,\n  "synchronous": false\n}' \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/actionBatches/:actionBatchId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "confirmed": false,
  "synchronous": false
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/admins");

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  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organizations/:organizationId/admins" {:content-type :json
                                                                                 :form-params {:authenticationMethod ""
                                                                                               :email ""
                                                                                               :name ""
                                                                                               :networks [{:access ""
                                                                                                           :id ""}]
                                                                                               :orgAccess ""
                                                                                               :tags [{:access ""
                                                                                                       :tag ""}]}})

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/admins"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins"),
    Content = new StringContent("{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/admins"

	payload := strings.NewReader("{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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/organizations/:organizationId/admins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 213

{
  "authenticationMethod": "",
  "email": "",
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organizations/:organizationId/admins")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/admins"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/admins")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/organizations/:organizationId/admins")
  .header("content-type", "application/json")
  .body("{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  authenticationMethod: '',
  email: '',
  name: '',
  networks: [
    {
      access: '',
      id: ''
    }
  ],
  orgAccess: '',
  tags: [
    {
      access: '',
      tag: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/organizations/:organizationId/admins');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organizations/:organizationId/admins',
  headers: {'content-type': 'application/json'},
  data: {
    authenticationMethod: '',
    email: '',
    name: '',
    networks: [{access: '', id: ''}],
    orgAccess: '',
    tags: [{access: '', tag: ''}]
  }
};

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

const url = '{{baseUrl}}/organizations/:organizationId/admins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authenticationMethod":"","email":"","name":"","networks":[{"access":"","id":""}],"orgAccess":"","tags":[{"access":"","tag":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organizations/:organizationId/admins',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authenticationMethod": "",\n  "email": "",\n  "name": "",\n  "networks": [\n    {\n      "access": "",\n      "id": ""\n    }\n  ],\n  "orgAccess": "",\n  "tags": [\n    {\n      "access": "",\n      "tag": ""\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  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/admins")
  .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/organizations/:organizationId/admins',
  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({
  authenticationMethod: '',
  email: '',
  name: '',
  networks: [{access: '', id: ''}],
  orgAccess: '',
  tags: [{access: '', tag: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organizations/:organizationId/admins',
  headers: {'content-type': 'application/json'},
  body: {
    authenticationMethod: '',
    email: '',
    name: '',
    networks: [{access: '', id: ''}],
    orgAccess: '',
    tags: [{access: '', tag: ''}]
  },
  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}}/organizations/:organizationId/admins');

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

req.type('json');
req.send({
  authenticationMethod: '',
  email: '',
  name: '',
  networks: [
    {
      access: '',
      id: ''
    }
  ],
  orgAccess: '',
  tags: [
    {
      access: '',
      tag: ''
    }
  ]
});

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}}/organizations/:organizationId/admins',
  headers: {'content-type': 'application/json'},
  data: {
    authenticationMethod: '',
    email: '',
    name: '',
    networks: [{access: '', id: ''}],
    orgAccess: '',
    tags: [{access: '', tag: ''}]
  }
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/admins';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authenticationMethod":"","email":"","name":"","networks":[{"access":"","id":""}],"orgAccess":"","tags":[{"access":"","tag":""}]}'
};

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 = @{ @"authenticationMethod": @"",
                              @"email": @"",
                              @"name": @"",
                              @"networks": @[ @{ @"access": @"", @"id": @"" } ],
                              @"orgAccess": @"",
                              @"tags": @[ @{ @"access": @"", @"tag": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/:organizationId/admins"]
                                                       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}}/organizations/:organizationId/admins" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/organizations/:organizationId/admins",
  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([
    'authenticationMethod' => '',
    'email' => '',
    'name' => '',
    'networks' => [
        [
                'access' => '',
                'id' => ''
        ]
    ],
    'orgAccess' => '',
    'tags' => [
        [
                'access' => '',
                'tag' => ''
        ]
    ]
  ]),
  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}}/organizations/:organizationId/admins', [
  'body' => '{
  "authenticationMethod": "",
  "email": "",
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/admins');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authenticationMethod' => '',
  'email' => '',
  'name' => '',
  'networks' => [
    [
        'access' => '',
        'id' => ''
    ]
  ],
  'orgAccess' => '',
  'tags' => [
    [
        'access' => '',
        'tag' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'authenticationMethod' => '',
  'email' => '',
  'name' => '',
  'networks' => [
    [
        'access' => '',
        'id' => ''
    ]
  ],
  'orgAccess' => '',
  'tags' => [
    [
        'access' => '',
        'tag' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/organizations/:organizationId/admins');
$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}}/organizations/:organizationId/admins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authenticationMethod": "",
  "email": "",
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/admins' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authenticationMethod": "",
  "email": "",
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/organizations/:organizationId/admins", payload, headers)

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/admins"

payload = {
    "authenticationMethod": "",
    "email": "",
    "name": "",
    "networks": [
        {
            "access": "",
            "id": ""
        }
    ],
    "orgAccess": "",
    "tags": [
        {
            "access": "",
            "tag": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/admins"

payload <- "{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins")

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  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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/organizations/:organizationId/admins') do |req|
  req.body = "{\n  \"authenticationMethod\": \"\",\n  \"email\": \"\",\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins";

    let payload = json!({
        "authenticationMethod": "",
        "email": "",
        "name": "",
        "networks": (
            json!({
                "access": "",
                "id": ""
            })
        ),
        "orgAccess": "",
        "tags": (
            json!({
                "access": "",
                "tag": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "authenticationMethod": "",
  "email": "",
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/organizations/:organizationId/admins \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authenticationMethod": "",\n  "email": "",\n  "name": "",\n  "networks": [\n    {\n      "access": "",\n      "id": ""\n    }\n  ],\n  "orgAccess": "",\n  "tags": [\n    {\n      "access": "",\n      "tag": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/admins

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authenticationMethod": "",
  "email": "",
  "name": "",
  "networks": [
    [
      "access": "",
      "id": ""
    ]
  ],
  "orgAccess": "",
  "tags": [
    [
      "access": "",
      "tag": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/admins");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/organizations/:organizationId/admins")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/admins"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/admins");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/admins"

	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/organizations/:organizationId/admins HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/organizations/:organizationId/admins'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/admins")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/organizations/:organizationId/admins');

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}}/organizations/:organizationId/admins'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/admins';
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}}/organizations/:organizationId/admins"]
                                                       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}}/organizations/:organizationId/admins" in

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

 "{{baseUrl}}/organizations/:organizationId/admins",
  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}}/organizations/:organizationId/admins');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/admins');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/admins');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/admins' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/admins' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/organizations/:organizationId/admins")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/admins"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/admins"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/admins")

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/organizations/:organizationId/admins') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/organizations/:organizationId/admins

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/admins

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/admins/:adminId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/organizations/:organizationId/admins/:adminId")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/admins/:adminId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

	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/organizations/:organizationId/admins/:adminId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .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}}/organizations/:organizationId/admins/:adminId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/organizations/:organizationId/admins/:adminId'
};

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

const url = '{{baseUrl}}/organizations/:organizationId/admins/:adminId';
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}}/organizations/:organizationId/admins/:adminId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/organizations/:organizationId/admins/:adminId',
  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}}/organizations/:organizationId/admins/:adminId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/organizations/:organizationId/admins/:adminId');

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}}/organizations/:organizationId/admins/:adminId'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/admins/:adminId';
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}}/organizations/:organizationId/admins/:adminId"]
                                                       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}}/organizations/:organizationId/admins/:adminId" in

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

 "{{baseUrl}}/organizations/:organizationId/admins/:adminId",
  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}}/organizations/:organizationId/admins/:adminId');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/admins/:adminId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/admins/:adminId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/admins/:adminId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/admins/:adminId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/organizations/:organizationId/admins/:adminId")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/admins/:adminId")

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/organizations/:organizationId/admins/:adminId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/organizations/:organizationId/admins/:adminId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/organizations/:organizationId/admins/:adminId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/admins/:adminId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/:organizationId/admins/:adminId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/admins/:adminId");

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  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/organizations/:organizationId/admins/:adminId" {:content-type :json
                                                                                         :form-params {:name ""
                                                                                                       :networks [{:access ""
                                                                                                                   :id ""}]
                                                                                                       :orgAccess ""
                                                                                                       :tags [{:access ""
                                                                                                               :tag ""}]}})

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/admins/:adminId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins/:adminId"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins/:adminId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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/organizations/:organizationId/admins/:adminId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 168

{
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/admins/:adminId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  networks: [
    {
      access: '',
      id: ''
    }
  ],
  orgAccess: '',
  tags: [
    {
      access: '',
      tag: ''
    }
  ]
});

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

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

xhr.open('PUT', '{{baseUrl}}/organizations/:organizationId/admins/:adminId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/organizations/:organizationId/admins/:adminId',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    networks: [{access: '', id: ''}],
    orgAccess: '',
    tags: [{access: '', tag: ''}]
  }
};

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

const url = '{{baseUrl}}/organizations/:organizationId/admins/:adminId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","networks":[{"access":"","id":""}],"orgAccess":"","tags":[{"access":"","tag":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organizations/:organizationId/admins/:adminId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "networks": [\n    {\n      "access": "",\n      "id": ""\n    }\n  ],\n  "orgAccess": "",\n  "tags": [\n    {\n      "access": "",\n      "tag": ""\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  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/admins/:adminId")
  .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/organizations/:organizationId/admins/:adminId',
  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: '',
  networks: [{access: '', id: ''}],
  orgAccess: '',
  tags: [{access: '', tag: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/organizations/:organizationId/admins/:adminId',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    networks: [{access: '', id: ''}],
    orgAccess: '',
    tags: [{access: '', tag: ''}]
  },
  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}}/organizations/:organizationId/admins/:adminId');

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

req.type('json');
req.send({
  name: '',
  networks: [
    {
      access: '',
      id: ''
    }
  ],
  orgAccess: '',
  tags: [
    {
      access: '',
      tag: ''
    }
  ]
});

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}}/organizations/:organizationId/admins/:adminId',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    networks: [{access: '', id: ''}],
    orgAccess: '',
    tags: [{access: '', tag: ''}]
  }
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/admins/:adminId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","networks":[{"access":"","id":""}],"orgAccess":"","tags":[{"access":"","tag":""}]}'
};

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": @"",
                              @"networks": @[ @{ @"access": @"", @"id": @"" } ],
                              @"orgAccess": @"",
                              @"tags": @[ @{ @"access": @"", @"tag": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organizations/:organizationId/admins/:adminId"]
                                                       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}}/organizations/:organizationId/admins/:adminId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/organizations/:organizationId/admins/:adminId",
  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' => '',
    'networks' => [
        [
                'access' => '',
                'id' => ''
        ]
    ],
    'orgAccess' => '',
    'tags' => [
        [
                'access' => '',
                'tag' => ''
        ]
    ]
  ]),
  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}}/organizations/:organizationId/admins/:adminId', [
  'body' => '{
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/admins/:adminId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'networks' => [
    [
        'access' => '',
        'id' => ''
    ]
  ],
  'orgAccess' => '',
  'tags' => [
    [
        'access' => '',
        'tag' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'networks' => [
    [
        'access' => '',
        'id' => ''
    ]
  ],
  'orgAccess' => '',
  'tags' => [
    [
        'access' => '',
        'tag' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/organizations/:organizationId/admins/:adminId');
$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}}/organizations/:organizationId/admins/:adminId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/admins/:adminId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\n    }\n  ]\n}"

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

conn.request("PUT", "/baseUrl/organizations/:organizationId/admins/:adminId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

payload = {
    "name": "",
    "networks": [
        {
            "access": "",
            "id": ""
        }
    ],
    "orgAccess": "",
    "tags": [
        {
            "access": "",
            "tag": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/admins/:adminId"

payload <- "{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins/:adminId")

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  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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/organizations/:organizationId/admins/:adminId') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"access\": \"\",\n      \"id\": \"\"\n    }\n  ],\n  \"orgAccess\": \"\",\n  \"tags\": [\n    {\n      \"access\": \"\",\n      \"tag\": \"\"\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}}/organizations/:organizationId/admins/:adminId";

    let payload = json!({
        "name": "",
        "networks": (
            json!({
                "access": "",
                "id": ""
            })
        ),
        "orgAccess": "",
        "tags": (
            json!({
                "access": "",
                "tag": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "name": "",
  "networks": [
    {
      "access": "",
      "id": ""
    }
  ],
  "orgAccess": "",
  "tags": [
    {
      "access": "",
      "tag": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/organizations/:organizationId/admins/:adminId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "networks": [\n    {\n      "access": "",\n      "id": ""\n    }\n  ],\n  "orgAccess": "",\n  "tags": [\n    {\n      "access": "",\n      "tag": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/admins/:adminId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "networks": [
    [
      "access": "",
      "id": ""
    ]
  ],
  "orgAccess": "",
  "tags": [
    [
      "access": "",
      "tag": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/alertSettings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/alertSettings")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/alertSettings"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/alertSettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/alertSettings"

	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/networks/:networkId/alertSettings HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/alertSettings'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/alertSettings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/alertSettings');

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}}/networks/:networkId/alertSettings'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/alertSettings';
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}}/networks/:networkId/alertSettings"]
                                                       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}}/networks/:networkId/alertSettings" in

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

 "{{baseUrl}}/networks/:networkId/alertSettings",
  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}}/networks/:networkId/alertSettings');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/alertSettings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/alertSettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/alertSettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/alertSettings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/alertSettings")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/alertSettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/alertSettings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/alertSettings")

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/networks/:networkId/alertSettings') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/alertSettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/alertSettings

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/alertSettings");

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  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/networks/:networkId/alertSettings" {:content-type :json
                                                                             :form-params {:alerts [{:alertDestinations {:allAdmins false
                                                                                                                         :emails []
                                                                                                                         :httpServerIds []
                                                                                                                         :snmp false}
                                                                                                     :enabled false
                                                                                                     :filters {}
                                                                                                     :type ""}]
                                                                                           :defaultDestinations {:allAdmins false
                                                                                                                 :emails []
                                                                                                                 :httpServerIds []
                                                                                                                 :snmp false}}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/alertSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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}}/networks/:networkId/alertSettings"),
    Content = new StringContent("{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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}}/networks/:networkId/alertSettings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/alertSettings"

	payload := strings.NewReader("{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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/networks/:networkId/alertSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 351

{
  "alerts": [
    {
      "alertDestinations": {
        "allAdmins": false,
        "emails": [],
        "httpServerIds": [],
        "snmp": false
      },
      "enabled": false,
      "filters": {},
      "type": ""
    }
  ],
  "defaultDestinations": {
    "allAdmins": false,
    "emails": [],
    "httpServerIds": [],
    "snmp": false
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/networks/:networkId/alertSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/alertSettings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/alertSettings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/networks/:networkId/alertSettings")
  .header("content-type", "application/json")
  .body("{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}")
  .asString();

const data = JSON.stringify({
  alerts: [
    {
      alertDestinations: {
        allAdmins: false,
        emails: [],
        httpServerIds: [],
        snmp: false
      },
      enabled: false,
      filters: {},
      type: ''
    }
  ],
  defaultDestinations: {
    allAdmins: false,
    emails: [],
    httpServerIds: [],
    snmp: false
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/networks/:networkId/alertSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/alertSettings',
  headers: {'content-type': 'application/json'},
  data: {
    alerts: [
      {
        alertDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false},
        enabled: false,
        filters: {},
        type: ''
      }
    ],
    defaultDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false}
  }
};

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

const url = '{{baseUrl}}/networks/:networkId/alertSettings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alerts":[{"alertDestinations":{"allAdmins":false,"emails":[],"httpServerIds":[],"snmp":false},"enabled":false,"filters":{},"type":""}],"defaultDestinations":{"allAdmins":false,"emails":[],"httpServerIds":[],"snmp":false}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/alertSettings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alerts": [\n    {\n      "alertDestinations": {\n        "allAdmins": false,\n        "emails": [],\n        "httpServerIds": [],\n        "snmp": false\n      },\n      "enabled": false,\n      "filters": {},\n      "type": ""\n    }\n  ],\n  "defaultDestinations": {\n    "allAdmins": false,\n    "emails": [],\n    "httpServerIds": [],\n    "snmp": false\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  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/alertSettings")
  .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/networks/:networkId/alertSettings',
  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({
  alerts: [
    {
      alertDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false},
      enabled: false,
      filters: {},
      type: ''
    }
  ],
  defaultDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/alertSettings',
  headers: {'content-type': 'application/json'},
  body: {
    alerts: [
      {
        alertDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false},
        enabled: false,
        filters: {},
        type: ''
      }
    ],
    defaultDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false}
  },
  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}}/networks/:networkId/alertSettings');

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

req.type('json');
req.send({
  alerts: [
    {
      alertDestinations: {
        allAdmins: false,
        emails: [],
        httpServerIds: [],
        snmp: false
      },
      enabled: false,
      filters: {},
      type: ''
    }
  ],
  defaultDestinations: {
    allAdmins: false,
    emails: [],
    httpServerIds: [],
    snmp: false
  }
});

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}}/networks/:networkId/alertSettings',
  headers: {'content-type': 'application/json'},
  data: {
    alerts: [
      {
        alertDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false},
        enabled: false,
        filters: {},
        type: ''
      }
    ],
    defaultDestinations: {allAdmins: false, emails: [], httpServerIds: [], snmp: false}
  }
};

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

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

const url = '{{baseUrl}}/networks/:networkId/alertSettings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alerts":[{"alertDestinations":{"allAdmins":false,"emails":[],"httpServerIds":[],"snmp":false},"enabled":false,"filters":{},"type":""}],"defaultDestinations":{"allAdmins":false,"emails":[],"httpServerIds":[],"snmp":false}}'
};

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 = @{ @"alerts": @[ @{ @"alertDestinations": @{ @"allAdmins": @NO, @"emails": @[  ], @"httpServerIds": @[  ], @"snmp": @NO }, @"enabled": @NO, @"filters": @{  }, @"type": @"" } ],
                              @"defaultDestinations": @{ @"allAdmins": @NO, @"emails": @[  ], @"httpServerIds": @[  ], @"snmp": @NO } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/alertSettings"]
                                                       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}}/networks/:networkId/alertSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}" in

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

 "{{baseUrl}}/networks/:networkId/alertSettings",
  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([
    'alerts' => [
        [
                'alertDestinations' => [
                                'allAdmins' => null,
                                'emails' => [
                                                                
                                ],
                                'httpServerIds' => [
                                                                
                                ],
                                'snmp' => null
                ],
                'enabled' => null,
                'filters' => [
                                
                ],
                'type' => ''
        ]
    ],
    'defaultDestinations' => [
        'allAdmins' => null,
        'emails' => [
                
        ],
        'httpServerIds' => [
                
        ],
        'snmp' => null
    ]
  ]),
  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}}/networks/:networkId/alertSettings', [
  'body' => '{
  "alerts": [
    {
      "alertDestinations": {
        "allAdmins": false,
        "emails": [],
        "httpServerIds": [],
        "snmp": false
      },
      "enabled": false,
      "filters": {},
      "type": ""
    }
  ],
  "defaultDestinations": {
    "allAdmins": false,
    "emails": [],
    "httpServerIds": [],
    "snmp": false
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/alertSettings');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alerts' => [
    [
        'alertDestinations' => [
                'allAdmins' => null,
                'emails' => [
                                
                ],
                'httpServerIds' => [
                                
                ],
                'snmp' => null
        ],
        'enabled' => null,
        'filters' => [
                
        ],
        'type' => ''
    ]
  ],
  'defaultDestinations' => [
    'allAdmins' => null,
    'emails' => [
        
    ],
    'httpServerIds' => [
        
    ],
    'snmp' => null
  ]
]));

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

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

append(json_encode([
  'alerts' => [
    [
        'alertDestinations' => [
                'allAdmins' => null,
                'emails' => [
                                
                ],
                'httpServerIds' => [
                                
                ],
                'snmp' => null
        ],
        'enabled' => null,
        'filters' => [
                
        ],
        'type' => ''
    ]
  ],
  'defaultDestinations' => [
    'allAdmins' => null,
    'emails' => [
        
    ],
    'httpServerIds' => [
        
    ],
    'snmp' => null
  ]
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/alertSettings');
$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}}/networks/:networkId/alertSettings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alerts": [
    {
      "alertDestinations": {
        "allAdmins": false,
        "emails": [],
        "httpServerIds": [],
        "snmp": false
      },
      "enabled": false,
      "filters": {},
      "type": ""
    }
  ],
  "defaultDestinations": {
    "allAdmins": false,
    "emails": [],
    "httpServerIds": [],
    "snmp": false
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/alertSettings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alerts": [
    {
      "alertDestinations": {
        "allAdmins": false,
        "emails": [],
        "httpServerIds": [],
        "snmp": false
      },
      "enabled": false,
      "filters": {},
      "type": ""
    }
  ],
  "defaultDestinations": {
    "allAdmins": false,
    "emails": [],
    "httpServerIds": [],
    "snmp": false
  }
}'

import http.client

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

payload = "{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\n  }\n}"

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

conn.request("PUT", "/baseUrl/networks/:networkId/alertSettings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/alertSettings"

payload = {
    "alerts": [
        {
            "alertDestinations": {
                "allAdmins": False,
                "emails": [],
                "httpServerIds": [],
                "snmp": False
            },
            "enabled": False,
            "filters": {},
            "type": ""
        }
    ],
    "defaultDestinations": {
        "allAdmins": False,
        "emails": [],
        "httpServerIds": [],
        "snmp": False
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/alertSettings"

payload <- "{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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}}/networks/:networkId/alertSettings")

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  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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/networks/:networkId/alertSettings') do |req|
  req.body = "{\n  \"alerts\": [\n    {\n      \"alertDestinations\": {\n        \"allAdmins\": false,\n        \"emails\": [],\n        \"httpServerIds\": [],\n        \"snmp\": false\n      },\n      \"enabled\": false,\n      \"filters\": {},\n      \"type\": \"\"\n    }\n  ],\n  \"defaultDestinations\": {\n    \"allAdmins\": false,\n    \"emails\": [],\n    \"httpServerIds\": [],\n    \"snmp\": false\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}}/networks/:networkId/alertSettings";

    let payload = json!({
        "alerts": (
            json!({
                "alertDestinations": json!({
                    "allAdmins": false,
                    "emails": (),
                    "httpServerIds": (),
                    "snmp": false
                }),
                "enabled": false,
                "filters": json!({}),
                "type": ""
            })
        ),
        "defaultDestinations": json!({
            "allAdmins": false,
            "emails": (),
            "httpServerIds": (),
            "snmp": false
        })
    });

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

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

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

    dbg!(results);
}

echo '{
  "alerts": [
    {
      "alertDestinations": {
        "allAdmins": false,
        "emails": [],
        "httpServerIds": [],
        "snmp": false
      },
      "enabled": false,
      "filters": {},
      "type": ""
    }
  ],
  "defaultDestinations": {
    "allAdmins": false,
    "emails": [],
    "httpServerIds": [],
    "snmp": false
  }
}' |  \
  http PUT {{baseUrl}}/networks/:networkId/alertSettings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alerts": [\n    {\n      "alertDestinations": {\n        "allAdmins": false,\n        "emails": [],\n        "httpServerIds": [],\n        "snmp": false\n      },\n      "enabled": false,\n      "filters": {},\n      "type": ""\n    }\n  ],\n  "defaultDestinations": {\n    "allAdmins": false,\n    "emails": [],\n    "httpServerIds": [],\n    "snmp": false\n  }\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/alertSettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alerts": [
    [
      "alertDestinations": [
        "allAdmins": false,
        "emails": [],
        "httpServerIds": [],
        "snmp": false
      ],
      "enabled": false,
      "filters": [],
      "type": ""
    ]
  ],
  "defaultDestinations": [
    "allAdmins": false,
    "emails": [],
    "httpServerIds": [],
    "snmp": false
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/apiRequests");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/organizations/:organizationId/apiRequests")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/apiRequests"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/apiRequests");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/apiRequests"

	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/organizations/:organizationId/apiRequests HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/organizations/:organizationId/apiRequests'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/apiRequests")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/organizations/:organizationId/apiRequests');

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}}/organizations/:organizationId/apiRequests'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/apiRequests';
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}}/organizations/:organizationId/apiRequests"]
                                                       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}}/organizations/:organizationId/apiRequests" in

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

 "{{baseUrl}}/organizations/:organizationId/apiRequests",
  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}}/organizations/:organizationId/apiRequests');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/apiRequests');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/apiRequests');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/apiRequests' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/apiRequests' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/organizations/:organizationId/apiRequests")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/apiRequests"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/apiRequests"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/apiRequests")

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/organizations/:organizationId/apiRequests') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/organizations/:organizationId/apiRequests

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/apiRequests

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/apiRequests/overview");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/organizations/:organizationId/apiRequests/overview")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/apiRequests/overview"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/apiRequests/overview");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/apiRequests/overview"

	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/organizations/:organizationId/apiRequests/overview HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/apiRequests/overview"))
    .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}}/organizations/:organizationId/apiRequests/overview")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/organizations/:organizationId/apiRequests/overview")
  .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}}/organizations/:organizationId/apiRequests/overview');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/organizations/:organizationId/apiRequests/overview'
};

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

const url = '{{baseUrl}}/organizations/:organizationId/apiRequests/overview';
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}}/organizations/:organizationId/apiRequests/overview',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/apiRequests/overview")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/organizations/:organizationId/apiRequests/overview');

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}}/organizations/:organizationId/apiRequests/overview'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/apiRequests/overview';
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}}/organizations/:organizationId/apiRequests/overview"]
                                                       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}}/organizations/:organizationId/apiRequests/overview" in

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

 "{{baseUrl}}/organizations/:organizationId/apiRequests/overview",
  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}}/organizations/:organizationId/apiRequests/overview');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/apiRequests/overview');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/apiRequests/overview');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/apiRequests/overview' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/apiRequests/overview' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/organizations/:organizationId/apiRequests/overview")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/apiRequests/overview"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/apiRequests/overview"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/apiRequests/overview")

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/organizations/:organizationId/apiRequests/overview') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/organizations/:organizationId/apiRequests/overview";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/organizations/:organizationId/apiRequests/overview

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/apiRequests/overview

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/bluetoothClients");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/bluetoothClients")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/bluetoothClients"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/bluetoothClients");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/bluetoothClients"

	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/networks/:networkId/bluetoothClients HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/bluetoothClients'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/bluetoothClients")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/bluetoothClients');

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}}/networks/:networkId/bluetoothClients'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/bluetoothClients';
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}}/networks/:networkId/bluetoothClients"]
                                                       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}}/networks/:networkId/bluetoothClients" in

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

 "{{baseUrl}}/networks/:networkId/bluetoothClients",
  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}}/networks/:networkId/bluetoothClients');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/bluetoothClients');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/bluetoothClients');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/bluetoothClients' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/bluetoothClients' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/bluetoothClients")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/bluetoothClients"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/bluetoothClients"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/bluetoothClients")

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/networks/:networkId/bluetoothClients') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/bluetoothClients

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/bluetoothClients

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId"

	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/networks/:networkId/bluetoothClients/:bluetoothClientId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId"))
    .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}}/networks/:networkId/bluetoothClients/:bluetoothClientId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId")
  .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}}/networks/:networkId/bluetoothClients/:bluetoothClientId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId'
};

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

const url = '{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId';
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}}/networks/:networkId/bluetoothClients/:bluetoothClientId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId');

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}}/networks/:networkId/bluetoothClients/:bluetoothClientId'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId';
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}}/networks/:networkId/bluetoothClients/:bluetoothClientId"]
                                                       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}}/networks/:networkId/bluetoothClients/:bluetoothClientId" in

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

 "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId",
  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}}/networks/:networkId/bluetoothClients/:bluetoothClientId');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/bluetoothClients/:bluetoothClientId")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId")

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/networks/:networkId/bluetoothClients/:bluetoothClientId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/bluetoothClients/:bluetoothClientId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/bluetoothSettings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/bluetoothSettings")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/bluetoothSettings"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/bluetoothSettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/bluetoothSettings"

	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/networks/:networkId/bluetoothSettings HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/bluetoothSettings'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/bluetoothSettings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/bluetoothSettings');

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}}/networks/:networkId/bluetoothSettings'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/bluetoothSettings';
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}}/networks/:networkId/bluetoothSettings"]
                                                       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}}/networks/:networkId/bluetoothSettings" in

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

 "{{baseUrl}}/networks/:networkId/bluetoothSettings",
  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}}/networks/:networkId/bluetoothSettings');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/bluetoothSettings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/bluetoothSettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/bluetoothSettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/bluetoothSettings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/bluetoothSettings")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/bluetoothSettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/bluetoothSettings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/bluetoothSettings")

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/networks/:networkId/bluetoothSettings') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/bluetoothSettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/bluetoothSettings

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/bluetoothSettings");

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  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/networks/:networkId/bluetoothSettings" {:content-type :json
                                                                                 :form-params {:advertisingEnabled false
                                                                                               :major 0
                                                                                               :majorMinorAssignmentMode ""
                                                                                               :minor 0
                                                                                               :scanningEnabled false
                                                                                               :uuid ""}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/bluetoothSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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}}/networks/:networkId/bluetoothSettings"),
    Content = new StringContent("{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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}}/networks/:networkId/bluetoothSettings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/bluetoothSettings"

	payload := strings.NewReader("{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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/networks/:networkId/bluetoothSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 137

{
  "advertisingEnabled": false,
  "major": 0,
  "majorMinorAssignmentMode": "",
  "minor": 0,
  "scanningEnabled": false,
  "uuid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/networks/:networkId/bluetoothSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/bluetoothSettings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/bluetoothSettings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/networks/:networkId/bluetoothSettings")
  .header("content-type", "application/json")
  .body("{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  advertisingEnabled: false,
  major: 0,
  majorMinorAssignmentMode: '',
  minor: 0,
  scanningEnabled: false,
  uuid: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/networks/:networkId/bluetoothSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/bluetoothSettings',
  headers: {'content-type': 'application/json'},
  data: {
    advertisingEnabled: false,
    major: 0,
    majorMinorAssignmentMode: '',
    minor: 0,
    scanningEnabled: false,
    uuid: ''
  }
};

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

const url = '{{baseUrl}}/networks/:networkId/bluetoothSettings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"advertisingEnabled":false,"major":0,"majorMinorAssignmentMode":"","minor":0,"scanningEnabled":false,"uuid":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/bluetoothSettings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "advertisingEnabled": false,\n  "major": 0,\n  "majorMinorAssignmentMode": "",\n  "minor": 0,\n  "scanningEnabled": false,\n  "uuid": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/bluetoothSettings")
  .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/networks/:networkId/bluetoothSettings',
  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({
  advertisingEnabled: false,
  major: 0,
  majorMinorAssignmentMode: '',
  minor: 0,
  scanningEnabled: false,
  uuid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/bluetoothSettings',
  headers: {'content-type': 'application/json'},
  body: {
    advertisingEnabled: false,
    major: 0,
    majorMinorAssignmentMode: '',
    minor: 0,
    scanningEnabled: false,
    uuid: ''
  },
  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}}/networks/:networkId/bluetoothSettings');

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

req.type('json');
req.send({
  advertisingEnabled: false,
  major: 0,
  majorMinorAssignmentMode: '',
  minor: 0,
  scanningEnabled: false,
  uuid: ''
});

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}}/networks/:networkId/bluetoothSettings',
  headers: {'content-type': 'application/json'},
  data: {
    advertisingEnabled: false,
    major: 0,
    majorMinorAssignmentMode: '',
    minor: 0,
    scanningEnabled: false,
    uuid: ''
  }
};

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

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

const url = '{{baseUrl}}/networks/:networkId/bluetoothSettings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"advertisingEnabled":false,"major":0,"majorMinorAssignmentMode":"","minor":0,"scanningEnabled":false,"uuid":""}'
};

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 = @{ @"advertisingEnabled": @NO,
                              @"major": @0,
                              @"majorMinorAssignmentMode": @"",
                              @"minor": @0,
                              @"scanningEnabled": @NO,
                              @"uuid": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/bluetoothSettings"]
                                                       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}}/networks/:networkId/bluetoothSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}" in

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

 "{{baseUrl}}/networks/:networkId/bluetoothSettings",
  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([
    'advertisingEnabled' => null,
    'major' => 0,
    'majorMinorAssignmentMode' => '',
    'minor' => 0,
    'scanningEnabled' => null,
    'uuid' => ''
  ]),
  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}}/networks/:networkId/bluetoothSettings', [
  'body' => '{
  "advertisingEnabled": false,
  "major": 0,
  "majorMinorAssignmentMode": "",
  "minor": 0,
  "scanningEnabled": false,
  "uuid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/bluetoothSettings');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'advertisingEnabled' => null,
  'major' => 0,
  'majorMinorAssignmentMode' => '',
  'minor' => 0,
  'scanningEnabled' => null,
  'uuid' => ''
]));

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

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

append(json_encode([
  'advertisingEnabled' => null,
  'major' => 0,
  'majorMinorAssignmentMode' => '',
  'minor' => 0,
  'scanningEnabled' => null,
  'uuid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/bluetoothSettings');
$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}}/networks/:networkId/bluetoothSettings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "advertisingEnabled": false,
  "major": 0,
  "majorMinorAssignmentMode": "",
  "minor": 0,
  "scanningEnabled": false,
  "uuid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/bluetoothSettings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "advertisingEnabled": false,
  "major": 0,
  "majorMinorAssignmentMode": "",
  "minor": 0,
  "scanningEnabled": false,
  "uuid": ""
}'

import http.client

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

payload = "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/networks/:networkId/bluetoothSettings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/bluetoothSettings"

payload = {
    "advertisingEnabled": False,
    "major": 0,
    "majorMinorAssignmentMode": "",
    "minor": 0,
    "scanningEnabled": False,
    "uuid": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/bluetoothSettings"

payload <- "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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}}/networks/:networkId/bluetoothSettings")

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  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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/networks/:networkId/bluetoothSettings') do |req|
  req.body = "{\n  \"advertisingEnabled\": false,\n  \"major\": 0,\n  \"majorMinorAssignmentMode\": \"\",\n  \"minor\": 0,\n  \"scanningEnabled\": false,\n  \"uuid\": \"\"\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}}/networks/:networkId/bluetoothSettings";

    let payload = json!({
        "advertisingEnabled": false,
        "major": 0,
        "majorMinorAssignmentMode": "",
        "minor": 0,
        "scanningEnabled": false,
        "uuid": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "advertisingEnabled": false,
  "major": 0,
  "majorMinorAssignmentMode": "",
  "minor": 0,
  "scanningEnabled": false,
  "uuid": ""
}' |  \
  http PUT {{baseUrl}}/networks/:networkId/bluetoothSettings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "advertisingEnabled": false,\n  "major": 0,\n  "majorMinorAssignmentMode": "",\n  "minor": 0,\n  "scanningEnabled": false,\n  "uuid": ""\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/bluetoothSettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "advertisingEnabled": false,
  "major": 0,
  "majorMinorAssignmentMode": "",
  "minor": 0,
  "scanningEnabled": false,
  "uuid": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings");

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  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings" {:content-type :json
                                                                                       :form-params {:major 0
                                                                                                     :minor 0
                                                                                                     :uuid ""}})

require "http/client"

url = "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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}}/devices/:serial/wireless/bluetooth/settings"),
    Content = new StringContent("{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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}}/devices/:serial/wireless/bluetooth/settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings"

	payload := strings.NewReader("{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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/devices/:serial/wireless/bluetooth/settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "major": 0,
  "minor": 0,
  "uuid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:serial/wireless/bluetooth/settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:serial/wireless/bluetooth/settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/devices/:serial/wireless/bluetooth/settings")
  .header("content-type", "application/json")
  .body("{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  major: 0,
  minor: 0,
  uuid: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings',
  headers: {'content-type': 'application/json'},
  data: {major: 0, minor: 0, uuid: ''}
};

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

const url = '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"major":0,"minor":0,"uuid":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "major": 0,\n  "minor": 0,\n  "uuid": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/wireless/bluetooth/settings")
  .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/devices/:serial/wireless/bluetooth/settings',
  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({major: 0, minor: 0, uuid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings',
  headers: {'content-type': 'application/json'},
  body: {major: 0, minor: 0, uuid: ''},
  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}}/devices/:serial/wireless/bluetooth/settings');

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

req.type('json');
req.send({
  major: 0,
  minor: 0,
  uuid: ''
});

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}}/devices/:serial/wireless/bluetooth/settings',
  headers: {'content-type': 'application/json'},
  data: {major: 0, minor: 0, uuid: ''}
};

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

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

const url = '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"major":0,"minor":0,"uuid":""}'
};

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 = @{ @"major": @0,
                              @"minor": @0,
                              @"uuid": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/devices/:serial/wireless/bluetooth/settings"]
                                                       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}}/devices/:serial/wireless/bluetooth/settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}" in

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

 "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings",
  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([
    'major' => 0,
    'minor' => 0,
    'uuid' => ''
  ]),
  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}}/devices/:serial/wireless/bluetooth/settings', [
  'body' => '{
  "major": 0,
  "minor": 0,
  "uuid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/wireless/bluetooth/settings');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'major' => 0,
  'minor' => 0,
  'uuid' => ''
]));

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

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

append(json_encode([
  'major' => 0,
  'minor' => 0,
  'uuid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/devices/:serial/wireless/bluetooth/settings');
$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}}/devices/:serial/wireless/bluetooth/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "major": 0,
  "minor": 0,
  "uuid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/wireless/bluetooth/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "major": 0,
  "minor": 0,
  "uuid": ""
}'

import http.client

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

payload = "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/devices/:serial/wireless/bluetooth/settings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings"

payload = {
    "major": 0,
    "minor": 0,
    "uuid": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings"

payload <- "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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}}/devices/:serial/wireless/bluetooth/settings")

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  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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/devices/:serial/wireless/bluetooth/settings') do |req|
  req.body = "{\n  \"major\": 0,\n  \"minor\": 0,\n  \"uuid\": \"\"\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}}/devices/:serial/wireless/bluetooth/settings";

    let payload = json!({
        "major": 0,
        "minor": 0,
        "uuid": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "major": 0,
  "minor": 0,
  "uuid": ""
}' |  \
  http PUT {{baseUrl}}/devices/:serial/wireless/bluetooth/settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "major": 0,\n  "minor": 0,\n  "uuid": ""\n}' \
  --output-document \
  - {{baseUrl}}/devices/:serial/wireless/bluetooth/settings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "major": 0,
  "minor": 0,
  "uuid": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/devices/:serial/wireless/bluetooth/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles");

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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles" {:content-type :json
                                                                                                :form-params {:audioRecordingEnabled false
                                                                                                              :cloudArchiveEnabled false
                                                                                                              :maxRetentionDays 0
                                                                                                              :motionBasedRetentionEnabled false
                                                                                                              :motionDetectorVersion 0
                                                                                                              :name ""
                                                                                                              :restrictedBandwidthModeEnabled false
                                                                                                              :scheduleId ""
                                                                                                              :videoSettings {:MV12/MV22/MV72 {:quality ""
                                                                                                                                               :resolution ""}
                                                                                                                              :MV12WE {:quality ""
                                                                                                                                       :resolution ""}
                                                                                                                              :MV13 {:quality ""
                                                                                                                                     :resolution ""}
                                                                                                                              :MV21/MV71 {:quality ""
                                                                                                                                          :resolution ""}
                                                                                                                              :MV22X/MV72X {:quality ""
                                                                                                                                            :resolution ""}
                                                                                                                              :MV32 {:quality ""
                                                                                                                                     :resolution ""}
                                                                                                                              :MV33 {:quality ""
                                                                                                                                     :resolution ""}
                                                                                                                              :MV52 {:quality ""
                                                                                                                                     :resolution ""}
                                                                                                                              :MV63 {:quality ""
                                                                                                                                     :resolution ""}
                                                                                                                              :MV63X {:quality ""
                                                                                                                                      :resolution ""}
                                                                                                                              :MV93 {:quality ""
                                                                                                                                     :resolution ""}
                                                                                                                              :MV93X {:quality ""
                                                                                                                                      :resolution ""}}}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles"),
    Content = new StringContent("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

	payload := strings.NewReader("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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/networks/:networkId/camera/qualityRetentionProfiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1071

{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")
  .header("content-type", "application/json")
  .body("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  audioRecordingEnabled: false,
  cloudArchiveEnabled: false,
  maxRetentionDays: 0,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  name: '',
  restrictedBandwidthModeEnabled: false,
  scheduleId: '',
  videoSettings: {
    'MV12/MV22/MV72': {
      quality: '',
      resolution: ''
    },
    MV12WE: {
      quality: '',
      resolution: ''
    },
    MV13: {
      quality: '',
      resolution: ''
    },
    'MV21/MV71': {
      quality: '',
      resolution: ''
    },
    'MV22X/MV72X': {
      quality: '',
      resolution: ''
    },
    MV32: {
      quality: '',
      resolution: ''
    },
    MV33: {
      quality: '',
      resolution: ''
    },
    MV52: {
      quality: '',
      resolution: ''
    },
    MV63: {
      quality: '',
      resolution: ''
    },
    MV63X: {
      quality: '',
      resolution: ''
    },
    MV93: {
      quality: '',
      resolution: ''
    },
    MV93X: {
      quality: '',
      resolution: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles',
  headers: {'content-type': 'application/json'},
  data: {
    audioRecordingEnabled: false,
    cloudArchiveEnabled: false,
    maxRetentionDays: 0,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    name: '',
    restrictedBandwidthModeEnabled: false,
    scheduleId: '',
    videoSettings: {
      'MV12/MV22/MV72': {quality: '', resolution: ''},
      MV12WE: {quality: '', resolution: ''},
      MV13: {quality: '', resolution: ''},
      'MV21/MV71': {quality: '', resolution: ''},
      'MV22X/MV72X': {quality: '', resolution: ''},
      MV32: {quality: '', resolution: ''},
      MV33: {quality: '', resolution: ''},
      MV52: {quality: '', resolution: ''},
      MV63: {quality: '', resolution: ''},
      MV63X: {quality: '', resolution: ''},
      MV93: {quality: '', resolution: ''},
      MV93X: {quality: '', resolution: ''}
    }
  }
};

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"audioRecordingEnabled":false,"cloudArchiveEnabled":false,"maxRetentionDays":0,"motionBasedRetentionEnabled":false,"motionDetectorVersion":0,"name":"","restrictedBandwidthModeEnabled":false,"scheduleId":"","videoSettings":{"MV12/MV22/MV72":{"quality":"","resolution":""},"MV12WE":{"quality":"","resolution":""},"MV13":{"quality":"","resolution":""},"MV21/MV71":{"quality":"","resolution":""},"MV22X/MV72X":{"quality":"","resolution":""},"MV32":{"quality":"","resolution":""},"MV33":{"quality":"","resolution":""},"MV52":{"quality":"","resolution":""},"MV63":{"quality":"","resolution":""},"MV63X":{"quality":"","resolution":""},"MV93":{"quality":"","resolution":""},"MV93X":{"quality":"","resolution":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "audioRecordingEnabled": false,\n  "cloudArchiveEnabled": false,\n  "maxRetentionDays": 0,\n  "motionBasedRetentionEnabled": false,\n  "motionDetectorVersion": 0,\n  "name": "",\n  "restrictedBandwidthModeEnabled": false,\n  "scheduleId": "",\n  "videoSettings": {\n    "MV12/MV22/MV72": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV12WE": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV13": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV21/MV71": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV22X/MV72X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV32": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV33": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV52": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93X": {\n      "quality": "",\n      "resolution": ""\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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")
  .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/networks/:networkId/camera/qualityRetentionProfiles',
  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({
  audioRecordingEnabled: false,
  cloudArchiveEnabled: false,
  maxRetentionDays: 0,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  name: '',
  restrictedBandwidthModeEnabled: false,
  scheduleId: '',
  videoSettings: {
    'MV12/MV22/MV72': {quality: '', resolution: ''},
    MV12WE: {quality: '', resolution: ''},
    MV13: {quality: '', resolution: ''},
    'MV21/MV71': {quality: '', resolution: ''},
    'MV22X/MV72X': {quality: '', resolution: ''},
    MV32: {quality: '', resolution: ''},
    MV33: {quality: '', resolution: ''},
    MV52: {quality: '', resolution: ''},
    MV63: {quality: '', resolution: ''},
    MV63X: {quality: '', resolution: ''},
    MV93: {quality: '', resolution: ''},
    MV93X: {quality: '', resolution: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles',
  headers: {'content-type': 'application/json'},
  body: {
    audioRecordingEnabled: false,
    cloudArchiveEnabled: false,
    maxRetentionDays: 0,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    name: '',
    restrictedBandwidthModeEnabled: false,
    scheduleId: '',
    videoSettings: {
      'MV12/MV22/MV72': {quality: '', resolution: ''},
      MV12WE: {quality: '', resolution: ''},
      MV13: {quality: '', resolution: ''},
      'MV21/MV71': {quality: '', resolution: ''},
      'MV22X/MV72X': {quality: '', resolution: ''},
      MV32: {quality: '', resolution: ''},
      MV33: {quality: '', resolution: ''},
      MV52: {quality: '', resolution: ''},
      MV63: {quality: '', resolution: ''},
      MV63X: {quality: '', resolution: ''},
      MV93: {quality: '', resolution: ''},
      MV93X: {quality: '', resolution: ''}
    }
  },
  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}}/networks/:networkId/camera/qualityRetentionProfiles');

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

req.type('json');
req.send({
  audioRecordingEnabled: false,
  cloudArchiveEnabled: false,
  maxRetentionDays: 0,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  name: '',
  restrictedBandwidthModeEnabled: false,
  scheduleId: '',
  videoSettings: {
    'MV12/MV22/MV72': {
      quality: '',
      resolution: ''
    },
    MV12WE: {
      quality: '',
      resolution: ''
    },
    MV13: {
      quality: '',
      resolution: ''
    },
    'MV21/MV71': {
      quality: '',
      resolution: ''
    },
    'MV22X/MV72X': {
      quality: '',
      resolution: ''
    },
    MV32: {
      quality: '',
      resolution: ''
    },
    MV33: {
      quality: '',
      resolution: ''
    },
    MV52: {
      quality: '',
      resolution: ''
    },
    MV63: {
      quality: '',
      resolution: ''
    },
    MV63X: {
      quality: '',
      resolution: ''
    },
    MV93: {
      quality: '',
      resolution: ''
    },
    MV93X: {
      quality: '',
      resolution: ''
    }
  }
});

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}}/networks/:networkId/camera/qualityRetentionProfiles',
  headers: {'content-type': 'application/json'},
  data: {
    audioRecordingEnabled: false,
    cloudArchiveEnabled: false,
    maxRetentionDays: 0,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    name: '',
    restrictedBandwidthModeEnabled: false,
    scheduleId: '',
    videoSettings: {
      'MV12/MV22/MV72': {quality: '', resolution: ''},
      MV12WE: {quality: '', resolution: ''},
      MV13: {quality: '', resolution: ''},
      'MV21/MV71': {quality: '', resolution: ''},
      'MV22X/MV72X': {quality: '', resolution: ''},
      MV32: {quality: '', resolution: ''},
      MV33: {quality: '', resolution: ''},
      MV52: {quality: '', resolution: ''},
      MV63: {quality: '', resolution: ''},
      MV63X: {quality: '', resolution: ''},
      MV93: {quality: '', resolution: ''},
      MV93X: {quality: '', resolution: ''}
    }
  }
};

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

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"audioRecordingEnabled":false,"cloudArchiveEnabled":false,"maxRetentionDays":0,"motionBasedRetentionEnabled":false,"motionDetectorVersion":0,"name":"","restrictedBandwidthModeEnabled":false,"scheduleId":"","videoSettings":{"MV12/MV22/MV72":{"quality":"","resolution":""},"MV12WE":{"quality":"","resolution":""},"MV13":{"quality":"","resolution":""},"MV21/MV71":{"quality":"","resolution":""},"MV22X/MV72X":{"quality":"","resolution":""},"MV32":{"quality":"","resolution":""},"MV33":{"quality":"","resolution":""},"MV52":{"quality":"","resolution":""},"MV63":{"quality":"","resolution":""},"MV63X":{"quality":"","resolution":""},"MV93":{"quality":"","resolution":""},"MV93X":{"quality":"","resolution":""}}}'
};

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 = @{ @"audioRecordingEnabled": @NO,
                              @"cloudArchiveEnabled": @NO,
                              @"maxRetentionDays": @0,
                              @"motionBasedRetentionEnabled": @NO,
                              @"motionDetectorVersion": @0,
                              @"name": @"",
                              @"restrictedBandwidthModeEnabled": @NO,
                              @"scheduleId": @"",
                              @"videoSettings": @{ @"MV12/MV22/MV72": @{ @"quality": @"", @"resolution": @"" }, @"MV12WE": @{ @"quality": @"", @"resolution": @"" }, @"MV13": @{ @"quality": @"", @"resolution": @"" }, @"MV21/MV71": @{ @"quality": @"", @"resolution": @"" }, @"MV22X/MV72X": @{ @"quality": @"", @"resolution": @"" }, @"MV32": @{ @"quality": @"", @"resolution": @"" }, @"MV33": @{ @"quality": @"", @"resolution": @"" }, @"MV52": @{ @"quality": @"", @"resolution": @"" }, @"MV63": @{ @"quality": @"", @"resolution": @"" }, @"MV63X": @{ @"quality": @"", @"resolution": @"" }, @"MV93": @{ @"quality": @"", @"resolution": @"" }, @"MV93X": @{ @"quality": @"", @"resolution": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"]
                                                       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}}/networks/:networkId/camera/qualityRetentionProfiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles",
  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([
    'audioRecordingEnabled' => null,
    'cloudArchiveEnabled' => null,
    'maxRetentionDays' => 0,
    'motionBasedRetentionEnabled' => null,
    'motionDetectorVersion' => 0,
    'name' => '',
    'restrictedBandwidthModeEnabled' => null,
    'scheduleId' => '',
    'videoSettings' => [
        'MV12/MV22/MV72' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV12WE' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV13' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV21/MV71' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV22X/MV72X' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV32' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV33' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV52' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV63' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV63X' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV93' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV93X' => [
                'quality' => '',
                'resolution' => ''
        ]
    ]
  ]),
  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}}/networks/:networkId/camera/qualityRetentionProfiles', [
  'body' => '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'audioRecordingEnabled' => null,
  'cloudArchiveEnabled' => null,
  'maxRetentionDays' => 0,
  'motionBasedRetentionEnabled' => null,
  'motionDetectorVersion' => 0,
  'name' => '',
  'restrictedBandwidthModeEnabled' => null,
  'scheduleId' => '',
  'videoSettings' => [
    'MV12/MV22/MV72' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV12WE' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV13' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV21/MV71' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV22X/MV72X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV32' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV33' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV52' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93X' => [
        'quality' => '',
        'resolution' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'audioRecordingEnabled' => null,
  'cloudArchiveEnabled' => null,
  'maxRetentionDays' => 0,
  'motionBasedRetentionEnabled' => null,
  'motionDetectorVersion' => 0,
  'name' => '',
  'restrictedBandwidthModeEnabled' => null,
  'scheduleId' => '',
  'videoSettings' => [
    'MV12/MV22/MV72' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV12WE' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV13' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV21/MV71' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV22X/MV72X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV32' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV33' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV52' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93X' => [
        'quality' => '',
        'resolution' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles');
$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}}/networks/:networkId/camera/qualityRetentionProfiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}"

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

conn.request("POST", "/baseUrl/networks/:networkId/camera/qualityRetentionProfiles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

payload = {
    "audioRecordingEnabled": False,
    "cloudArchiveEnabled": False,
    "maxRetentionDays": 0,
    "motionBasedRetentionEnabled": False,
    "motionDetectorVersion": 0,
    "name": "",
    "restrictedBandwidthModeEnabled": False,
    "scheduleId": "",
    "videoSettings": {
        "MV12/MV22/MV72": {
            "quality": "",
            "resolution": ""
        },
        "MV12WE": {
            "quality": "",
            "resolution": ""
        },
        "MV13": {
            "quality": "",
            "resolution": ""
        },
        "MV21/MV71": {
            "quality": "",
            "resolution": ""
        },
        "MV22X/MV72X": {
            "quality": "",
            "resolution": ""
        },
        "MV32": {
            "quality": "",
            "resolution": ""
        },
        "MV33": {
            "quality": "",
            "resolution": ""
        },
        "MV52": {
            "quality": "",
            "resolution": ""
        },
        "MV63": {
            "quality": "",
            "resolution": ""
        },
        "MV63X": {
            "quality": "",
            "resolution": ""
        },
        "MV93": {
            "quality": "",
            "resolution": ""
        },
        "MV93X": {
            "quality": "",
            "resolution": ""
        }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

payload <- "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles")

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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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/networks/:networkId/camera/qualityRetentionProfiles') do |req|
  req.body = "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles";

    let payload = json!({
        "audioRecordingEnabled": false,
        "cloudArchiveEnabled": false,
        "maxRetentionDays": 0,
        "motionBasedRetentionEnabled": false,
        "motionDetectorVersion": 0,
        "name": "",
        "restrictedBandwidthModeEnabled": false,
        "scheduleId": "",
        "videoSettings": json!({
            "MV12/MV22/MV72": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV12WE": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV13": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV21/MV71": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV22X/MV72X": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV32": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV33": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV52": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV63": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV63X": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV93": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV93X": json!({
                "quality": "",
                "resolution": ""
            })
        })
    });

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

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

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

    dbg!(results);
}

echo '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "audioRecordingEnabled": false,\n  "cloudArchiveEnabled": false,\n  "maxRetentionDays": 0,\n  "motionBasedRetentionEnabled": false,\n  "motionDetectorVersion": 0,\n  "name": "",\n  "restrictedBandwidthModeEnabled": false,\n  "scheduleId": "",\n  "videoSettings": {\n    "MV12/MV22/MV72": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV12WE": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV13": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV21/MV71": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV22X/MV72X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV32": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV33": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV52": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93X": {\n      "quality": "",\n      "resolution": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": [
    "MV12/MV22/MV72": [
      "quality": "",
      "resolution": ""
    ],
    "MV12WE": [
      "quality": "",
      "resolution": ""
    ],
    "MV13": [
      "quality": "",
      "resolution": ""
    ],
    "MV21/MV71": [
      "quality": "",
      "resolution": ""
    ],
    "MV22X/MV72X": [
      "quality": "",
      "resolution": ""
    ],
    "MV32": [
      "quality": "",
      "resolution": ""
    ],
    "MV33": [
      "quality": "",
      "resolution": ""
    ],
    "MV52": [
      "quality": "",
      "resolution": ""
    ],
    "MV63": [
      "quality": "",
      "resolution": ""
    ],
    "MV63X": [
      "quality": "",
      "resolution": ""
    ],
    "MV93": [
      "quality": "",
      "resolution": ""
    ],
    "MV93X": [
      "quality": "",
      "resolution": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

	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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"))
    .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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId'
};

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId';
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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId';
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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"]
                                                       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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId" in

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

 "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId",
  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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

	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/networks/:networkId/camera/qualityRetentionProfiles HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"))
    .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}}/networks/:networkId/camera/qualityRetentionProfiles")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")
  .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}}/networks/:networkId/camera/qualityRetentionProfiles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles'
};

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles';
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}}/networks/:networkId/camera/qualityRetentionProfiles',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles');

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}}/networks/:networkId/camera/qualityRetentionProfiles'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles';
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}}/networks/:networkId/camera/qualityRetentionProfiles"]
                                                       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}}/networks/:networkId/camera/qualityRetentionProfiles" in

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

 "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles",
  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}}/networks/:networkId/camera/qualityRetentionProfiles');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/camera/qualityRetentionProfiles")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles")

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/networks/:networkId/camera/qualityRetentionProfiles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

	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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"))
    .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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId'
};

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId';
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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId';
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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"]
                                                       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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId" in

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

 "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId",
  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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId");

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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId" {:content-type :json
                                                                                                                          :form-params {:audioRecordingEnabled false
                                                                                                                                        :cloudArchiveEnabled false
                                                                                                                                        :maxRetentionDays 0
                                                                                                                                        :motionBasedRetentionEnabled false
                                                                                                                                        :motionDetectorVersion 0
                                                                                                                                        :name ""
                                                                                                                                        :restrictedBandwidthModeEnabled false
                                                                                                                                        :scheduleId ""
                                                                                                                                        :videoSettings {:MV12/MV22/MV72 {:quality ""
                                                                                                                                                                         :resolution ""}
                                                                                                                                                        :MV12WE {:quality ""
                                                                                                                                                                 :resolution ""}
                                                                                                                                                        :MV13 {:quality ""
                                                                                                                                                               :resolution ""}
                                                                                                                                                        :MV21/MV71 {:quality ""
                                                                                                                                                                    :resolution ""}
                                                                                                                                                        :MV22X/MV72X {:quality ""
                                                                                                                                                                      :resolution ""}
                                                                                                                                                        :MV32 {:quality ""
                                                                                                                                                               :resolution ""}
                                                                                                                                                        :MV33 {:quality ""
                                                                                                                                                               :resolution ""}
                                                                                                                                                        :MV52 {:quality ""
                                                                                                                                                               :resolution ""}
                                                                                                                                                        :MV63 {:quality ""
                                                                                                                                                               :resolution ""}
                                                                                                                                                        :MV63X {:quality ""
                                                                                                                                                                :resolution ""}
                                                                                                                                                        :MV93 {:quality ""
                                                                                                                                                               :resolution ""}
                                                                                                                                                        :MV93X {:quality ""
                                                                                                                                                                :resolution ""}}}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"),
    Content = new StringContent("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

	payload := strings.NewReader("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1071

{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .header("content-type", "application/json")
  .body("{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  audioRecordingEnabled: false,
  cloudArchiveEnabled: false,
  maxRetentionDays: 0,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  name: '',
  restrictedBandwidthModeEnabled: false,
  scheduleId: '',
  videoSettings: {
    'MV12/MV22/MV72': {
      quality: '',
      resolution: ''
    },
    MV12WE: {
      quality: '',
      resolution: ''
    },
    MV13: {
      quality: '',
      resolution: ''
    },
    'MV21/MV71': {
      quality: '',
      resolution: ''
    },
    'MV22X/MV72X': {
      quality: '',
      resolution: ''
    },
    MV32: {
      quality: '',
      resolution: ''
    },
    MV33: {
      quality: '',
      resolution: ''
    },
    MV52: {
      quality: '',
      resolution: ''
    },
    MV63: {
      quality: '',
      resolution: ''
    },
    MV63X: {
      quality: '',
      resolution: ''
    },
    MV93: {
      quality: '',
      resolution: ''
    },
    MV93X: {
      quality: '',
      resolution: ''
    }
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  headers: {'content-type': 'application/json'},
  data: {
    audioRecordingEnabled: false,
    cloudArchiveEnabled: false,
    maxRetentionDays: 0,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    name: '',
    restrictedBandwidthModeEnabled: false,
    scheduleId: '',
    videoSettings: {
      'MV12/MV22/MV72': {quality: '', resolution: ''},
      MV12WE: {quality: '', resolution: ''},
      MV13: {quality: '', resolution: ''},
      'MV21/MV71': {quality: '', resolution: ''},
      'MV22X/MV72X': {quality: '', resolution: ''},
      MV32: {quality: '', resolution: ''},
      MV33: {quality: '', resolution: ''},
      MV52: {quality: '', resolution: ''},
      MV63: {quality: '', resolution: ''},
      MV63X: {quality: '', resolution: ''},
      MV93: {quality: '', resolution: ''},
      MV93X: {quality: '', resolution: ''}
    }
  }
};

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"audioRecordingEnabled":false,"cloudArchiveEnabled":false,"maxRetentionDays":0,"motionBasedRetentionEnabled":false,"motionDetectorVersion":0,"name":"","restrictedBandwidthModeEnabled":false,"scheduleId":"","videoSettings":{"MV12/MV22/MV72":{"quality":"","resolution":""},"MV12WE":{"quality":"","resolution":""},"MV13":{"quality":"","resolution":""},"MV21/MV71":{"quality":"","resolution":""},"MV22X/MV72X":{"quality":"","resolution":""},"MV32":{"quality":"","resolution":""},"MV33":{"quality":"","resolution":""},"MV52":{"quality":"","resolution":""},"MV63":{"quality":"","resolution":""},"MV63X":{"quality":"","resolution":""},"MV93":{"quality":"","resolution":""},"MV93X":{"quality":"","resolution":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "audioRecordingEnabled": false,\n  "cloudArchiveEnabled": false,\n  "maxRetentionDays": 0,\n  "motionBasedRetentionEnabled": false,\n  "motionDetectorVersion": 0,\n  "name": "",\n  "restrictedBandwidthModeEnabled": false,\n  "scheduleId": "",\n  "videoSettings": {\n    "MV12/MV22/MV72": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV12WE": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV13": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV21/MV71": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV22X/MV72X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV32": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV33": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV52": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93X": {\n      "quality": "",\n      "resolution": ""\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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")
  .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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  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({
  audioRecordingEnabled: false,
  cloudArchiveEnabled: false,
  maxRetentionDays: 0,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  name: '',
  restrictedBandwidthModeEnabled: false,
  scheduleId: '',
  videoSettings: {
    'MV12/MV22/MV72': {quality: '', resolution: ''},
    MV12WE: {quality: '', resolution: ''},
    MV13: {quality: '', resolution: ''},
    'MV21/MV71': {quality: '', resolution: ''},
    'MV22X/MV72X': {quality: '', resolution: ''},
    MV32: {quality: '', resolution: ''},
    MV33: {quality: '', resolution: ''},
    MV52: {quality: '', resolution: ''},
    MV63: {quality: '', resolution: ''},
    MV63X: {quality: '', resolution: ''},
    MV93: {quality: '', resolution: ''},
    MV93X: {quality: '', resolution: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  headers: {'content-type': 'application/json'},
  body: {
    audioRecordingEnabled: false,
    cloudArchiveEnabled: false,
    maxRetentionDays: 0,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    name: '',
    restrictedBandwidthModeEnabled: false,
    scheduleId: '',
    videoSettings: {
      'MV12/MV22/MV72': {quality: '', resolution: ''},
      MV12WE: {quality: '', resolution: ''},
      MV13: {quality: '', resolution: ''},
      'MV21/MV71': {quality: '', resolution: ''},
      'MV22X/MV72X': {quality: '', resolution: ''},
      MV32: {quality: '', resolution: ''},
      MV33: {quality: '', resolution: ''},
      MV52: {quality: '', resolution: ''},
      MV63: {quality: '', resolution: ''},
      MV63X: {quality: '', resolution: ''},
      MV93: {quality: '', resolution: ''},
      MV93X: {quality: '', resolution: ''}
    }
  },
  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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');

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

req.type('json');
req.send({
  audioRecordingEnabled: false,
  cloudArchiveEnabled: false,
  maxRetentionDays: 0,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  name: '',
  restrictedBandwidthModeEnabled: false,
  scheduleId: '',
  videoSettings: {
    'MV12/MV22/MV72': {
      quality: '',
      resolution: ''
    },
    MV12WE: {
      quality: '',
      resolution: ''
    },
    MV13: {
      quality: '',
      resolution: ''
    },
    'MV21/MV71': {
      quality: '',
      resolution: ''
    },
    'MV22X/MV72X': {
      quality: '',
      resolution: ''
    },
    MV32: {
      quality: '',
      resolution: ''
    },
    MV33: {
      quality: '',
      resolution: ''
    },
    MV52: {
      quality: '',
      resolution: ''
    },
    MV63: {
      quality: '',
      resolution: ''
    },
    MV63X: {
      quality: '',
      resolution: ''
    },
    MV93: {
      quality: '',
      resolution: ''
    },
    MV93X: {
      quality: '',
      resolution: ''
    }
  }
});

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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId',
  headers: {'content-type': 'application/json'},
  data: {
    audioRecordingEnabled: false,
    cloudArchiveEnabled: false,
    maxRetentionDays: 0,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    name: '',
    restrictedBandwidthModeEnabled: false,
    scheduleId: '',
    videoSettings: {
      'MV12/MV22/MV72': {quality: '', resolution: ''},
      MV12WE: {quality: '', resolution: ''},
      MV13: {quality: '', resolution: ''},
      'MV21/MV71': {quality: '', resolution: ''},
      'MV22X/MV72X': {quality: '', resolution: ''},
      MV32: {quality: '', resolution: ''},
      MV33: {quality: '', resolution: ''},
      MV52: {quality: '', resolution: ''},
      MV63: {quality: '', resolution: ''},
      MV63X: {quality: '', resolution: ''},
      MV93: {quality: '', resolution: ''},
      MV93X: {quality: '', resolution: ''}
    }
  }
};

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

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

const url = '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"audioRecordingEnabled":false,"cloudArchiveEnabled":false,"maxRetentionDays":0,"motionBasedRetentionEnabled":false,"motionDetectorVersion":0,"name":"","restrictedBandwidthModeEnabled":false,"scheduleId":"","videoSettings":{"MV12/MV22/MV72":{"quality":"","resolution":""},"MV12WE":{"quality":"","resolution":""},"MV13":{"quality":"","resolution":""},"MV21/MV71":{"quality":"","resolution":""},"MV22X/MV72X":{"quality":"","resolution":""},"MV32":{"quality":"","resolution":""},"MV33":{"quality":"","resolution":""},"MV52":{"quality":"","resolution":""},"MV63":{"quality":"","resolution":""},"MV63X":{"quality":"","resolution":""},"MV93":{"quality":"","resolution":""},"MV93X":{"quality":"","resolution":""}}}'
};

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 = @{ @"audioRecordingEnabled": @NO,
                              @"cloudArchiveEnabled": @NO,
                              @"maxRetentionDays": @0,
                              @"motionBasedRetentionEnabled": @NO,
                              @"motionDetectorVersion": @0,
                              @"name": @"",
                              @"restrictedBandwidthModeEnabled": @NO,
                              @"scheduleId": @"",
                              @"videoSettings": @{ @"MV12/MV22/MV72": @{ @"quality": @"", @"resolution": @"" }, @"MV12WE": @{ @"quality": @"", @"resolution": @"" }, @"MV13": @{ @"quality": @"", @"resolution": @"" }, @"MV21/MV71": @{ @"quality": @"", @"resolution": @"" }, @"MV22X/MV72X": @{ @"quality": @"", @"resolution": @"" }, @"MV32": @{ @"quality": @"", @"resolution": @"" }, @"MV33": @{ @"quality": @"", @"resolution": @"" }, @"MV52": @{ @"quality": @"", @"resolution": @"" }, @"MV63": @{ @"quality": @"", @"resolution": @"" }, @"MV63X": @{ @"quality": @"", @"resolution": @"" }, @"MV93": @{ @"quality": @"", @"resolution": @"" }, @"MV93X": @{ @"quality": @"", @"resolution": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"]
                                                       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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId",
  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([
    'audioRecordingEnabled' => null,
    'cloudArchiveEnabled' => null,
    'maxRetentionDays' => 0,
    'motionBasedRetentionEnabled' => null,
    'motionDetectorVersion' => 0,
    'name' => '',
    'restrictedBandwidthModeEnabled' => null,
    'scheduleId' => '',
    'videoSettings' => [
        'MV12/MV22/MV72' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV12WE' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV13' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV21/MV71' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV22X/MV72X' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV32' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV33' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV52' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV63' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV63X' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV93' => [
                'quality' => '',
                'resolution' => ''
        ],
        'MV93X' => [
                'quality' => '',
                'resolution' => ''
        ]
    ]
  ]),
  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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId', [
  'body' => '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'audioRecordingEnabled' => null,
  'cloudArchiveEnabled' => null,
  'maxRetentionDays' => 0,
  'motionBasedRetentionEnabled' => null,
  'motionDetectorVersion' => 0,
  'name' => '',
  'restrictedBandwidthModeEnabled' => null,
  'scheduleId' => '',
  'videoSettings' => [
    'MV12/MV22/MV72' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV12WE' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV13' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV21/MV71' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV22X/MV72X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV32' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV33' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV52' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93X' => [
        'quality' => '',
        'resolution' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'audioRecordingEnabled' => null,
  'cloudArchiveEnabled' => null,
  'maxRetentionDays' => 0,
  'motionBasedRetentionEnabled' => null,
  'motionDetectorVersion' => 0,
  'name' => '',
  'restrictedBandwidthModeEnabled' => null,
  'scheduleId' => '',
  'videoSettings' => [
    'MV12/MV22/MV72' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV12WE' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV13' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV21/MV71' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV22X/MV72X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV32' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV33' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV52' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV63X' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93' => [
        'quality' => '',
        'resolution' => ''
    ],
    'MV93X' => [
        'quality' => '',
        'resolution' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId');
$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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    }\n  }\n}"

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

conn.request("PUT", "/baseUrl/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

payload = {
    "audioRecordingEnabled": False,
    "cloudArchiveEnabled": False,
    "maxRetentionDays": 0,
    "motionBasedRetentionEnabled": False,
    "motionDetectorVersion": 0,
    "name": "",
    "restrictedBandwidthModeEnabled": False,
    "scheduleId": "",
    "videoSettings": {
        "MV12/MV22/MV72": {
            "quality": "",
            "resolution": ""
        },
        "MV12WE": {
            "quality": "",
            "resolution": ""
        },
        "MV13": {
            "quality": "",
            "resolution": ""
        },
        "MV21/MV71": {
            "quality": "",
            "resolution": ""
        },
        "MV22X/MV72X": {
            "quality": "",
            "resolution": ""
        },
        "MV32": {
            "quality": "",
            "resolution": ""
        },
        "MV33": {
            "quality": "",
            "resolution": ""
        },
        "MV52": {
            "quality": "",
            "resolution": ""
        },
        "MV63": {
            "quality": "",
            "resolution": ""
        },
        "MV63X": {
            "quality": "",
            "resolution": ""
        },
        "MV93": {
            "quality": "",
            "resolution": ""
        },
        "MV93X": {
            "quality": "",
            "resolution": ""
        }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId"

payload <- "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")

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  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId') do |req|
  req.body = "{\n  \"audioRecordingEnabled\": false,\n  \"cloudArchiveEnabled\": false,\n  \"maxRetentionDays\": 0,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"name\": \"\",\n  \"restrictedBandwidthModeEnabled\": false,\n  \"scheduleId\": \"\",\n  \"videoSettings\": {\n    \"MV12/MV22/MV72\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV12WE\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV13\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV21/MV71\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV22X/MV72X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV32\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV33\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV52\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV63X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\n    },\n    \"MV93X\": {\n      \"quality\": \"\",\n      \"resolution\": \"\"\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}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId";

    let payload = json!({
        "audioRecordingEnabled": false,
        "cloudArchiveEnabled": false,
        "maxRetentionDays": 0,
        "motionBasedRetentionEnabled": false,
        "motionDetectorVersion": 0,
        "name": "",
        "restrictedBandwidthModeEnabled": false,
        "scheduleId": "",
        "videoSettings": json!({
            "MV12/MV22/MV72": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV12WE": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV13": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV21/MV71": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV22X/MV72X": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV32": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV33": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV52": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV63": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV63X": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV93": json!({
                "quality": "",
                "resolution": ""
            }),
            "MV93X": json!({
                "quality": "",
                "resolution": ""
            })
        })
    });

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

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

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

    dbg!(results);
}

echo '{
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": {
    "MV12/MV22/MV72": {
      "quality": "",
      "resolution": ""
    },
    "MV12WE": {
      "quality": "",
      "resolution": ""
    },
    "MV13": {
      "quality": "",
      "resolution": ""
    },
    "MV21/MV71": {
      "quality": "",
      "resolution": ""
    },
    "MV22X/MV72X": {
      "quality": "",
      "resolution": ""
    },
    "MV32": {
      "quality": "",
      "resolution": ""
    },
    "MV33": {
      "quality": "",
      "resolution": ""
    },
    "MV52": {
      "quality": "",
      "resolution": ""
    },
    "MV63": {
      "quality": "",
      "resolution": ""
    },
    "MV63X": {
      "quality": "",
      "resolution": ""
    },
    "MV93": {
      "quality": "",
      "resolution": ""
    },
    "MV93X": {
      "quality": "",
      "resolution": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "audioRecordingEnabled": false,\n  "cloudArchiveEnabled": false,\n  "maxRetentionDays": 0,\n  "motionBasedRetentionEnabled": false,\n  "motionDetectorVersion": 0,\n  "name": "",\n  "restrictedBandwidthModeEnabled": false,\n  "scheduleId": "",\n  "videoSettings": {\n    "MV12/MV22/MV72": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV12WE": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV13": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV21/MV71": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV22X/MV72X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV32": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV33": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV52": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV63X": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93": {\n      "quality": "",\n      "resolution": ""\n    },\n    "MV93X": {\n      "quality": "",\n      "resolution": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "audioRecordingEnabled": false,
  "cloudArchiveEnabled": false,
  "maxRetentionDays": 0,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "name": "",
  "restrictedBandwidthModeEnabled": false,
  "scheduleId": "",
  "videoSettings": [
    "MV12/MV22/MV72": [
      "quality": "",
      "resolution": ""
    ],
    "MV12WE": [
      "quality": "",
      "resolution": ""
    ],
    "MV13": [
      "quality": "",
      "resolution": ""
    ],
    "MV21/MV71": [
      "quality": "",
      "resolution": ""
    ],
    "MV22X/MV72X": [
      "quality": "",
      "resolution": ""
    ],
    "MV32": [
      "quality": "",
      "resolution": ""
    ],
    "MV33": [
      "quality": "",
      "resolution": ""
    ],
    "MV52": [
      "quality": "",
      "resolution": ""
    ],
    "MV63": [
      "quality": "",
      "resolution": ""
    ],
    "MV63X": [
      "quality": "",
      "resolution": ""
    ],
    "MV93": [
      "quality": "",
      "resolution": ""
    ],
    "MV93X": [
      "quality": "",
      "resolution": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/camera/qualityRetentionProfiles/:qualityRetentionProfileId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot");

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  \"fullframe\": false,\n  \"timestamp\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot" {:content-type :json
                                                                                         :form-params {:fullframe false
                                                                                                       :timestamp ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot"

	payload := strings.NewReader("{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\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/networks/:networkId/cameras/:serial/snapshot HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "fullframe": false,
  "timestamp": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot")
  .header("content-type", "application/json")
  .body("{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  fullframe: false,
  timestamp: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot',
  headers: {'content-type': 'application/json'},
  data: {fullframe: false, timestamp: ''}
};

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

const url = '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fullframe":false,"timestamp":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fullframe": false,\n  "timestamp": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot")
  .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/networks/:networkId/cameras/:serial/snapshot',
  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({fullframe: false, timestamp: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot',
  headers: {'content-type': 'application/json'},
  body: {fullframe: false, timestamp: ''},
  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}}/networks/:networkId/cameras/:serial/snapshot');

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

req.type('json');
req.send({
  fullframe: false,
  timestamp: ''
});

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}}/networks/:networkId/cameras/:serial/snapshot',
  headers: {'content-type': 'application/json'},
  data: {fullframe: false, timestamp: ''}
};

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

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

const url = '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fullframe":false,"timestamp":""}'
};

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 = @{ @"fullframe": @NO,
                              @"timestamp": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot"]
                                                       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}}/networks/:networkId/cameras/:serial/snapshot" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\n}" in

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

 "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot",
  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([
    'fullframe' => null,
    'timestamp' => ''
  ]),
  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}}/networks/:networkId/cameras/:serial/snapshot', [
  'body' => '{
  "fullframe": false,
  "timestamp": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fullframe' => null,
  'timestamp' => ''
]));

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

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

append(json_encode([
  'fullframe' => null,
  'timestamp' => ''
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot');
$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}}/networks/:networkId/cameras/:serial/snapshot' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fullframe": false,
  "timestamp": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fullframe": false,
  "timestamp": ""
}'

import http.client

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

payload = "{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\n}"

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

conn.request("POST", "/baseUrl/networks/:networkId/cameras/:serial/snapshot", payload, headers)

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot"

payload = {
    "fullframe": False,
    "timestamp": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot"

payload <- "{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\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}}/networks/:networkId/cameras/:serial/snapshot")

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  \"fullframe\": false,\n  \"timestamp\": \"\"\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/networks/:networkId/cameras/:serial/snapshot') do |req|
  req.body = "{\n  \"fullframe\": false,\n  \"timestamp\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/cameras/:serial/snapshot";

    let payload = json!({
        "fullframe": false,
        "timestamp": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "fullframe": false,
  "timestamp": ""
}' |  \
  http POST {{baseUrl}}/networks/:networkId/cameras/:serial/snapshot \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fullframe": false,\n  "timestamp": ""\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/cameras/:serial/snapshot

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "fullframe": false,
  "timestamp": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/camera/schedules");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/camera/schedules")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/camera/schedules"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/camera/schedules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/camera/schedules"

	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/networks/:networkId/camera/schedules HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/camera/schedules"))
    .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}}/networks/:networkId/camera/schedules")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/camera/schedules")
  .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}}/networks/:networkId/camera/schedules');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/camera/schedules'
};

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

const url = '{{baseUrl}}/networks/:networkId/camera/schedules';
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}}/networks/:networkId/camera/schedules',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/camera/schedules")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/camera/schedules');

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}}/networks/:networkId/camera/schedules'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/camera/schedules';
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}}/networks/:networkId/camera/schedules"]
                                                       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}}/networks/:networkId/camera/schedules" in

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

 "{{baseUrl}}/networks/:networkId/camera/schedules",
  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}}/networks/:networkId/camera/schedules');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/camera/schedules');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/camera/schedules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/camera/schedules' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/camera/schedules' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/camera/schedules")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/camera/schedules"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/camera/schedules"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/camera/schedules")

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/networks/:networkId/camera/schedules') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/camera/schedules";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/camera/schedules

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/camera/schedules

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")

require "http/client"

url = "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

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

var client = new RestClient("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

	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/devices/:serial/camera/qualityAndRetentionSettings HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"))
    .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}}/devices/:serial/camera/qualityAndRetentionSettings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")
  .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}}/devices/:serial/camera/qualityAndRetentionSettings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings'
};

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

const url = '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings';
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}}/devices/:serial/camera/qualityAndRetentionSettings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings');

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}}/devices/:serial/camera/qualityAndRetentionSettings'
};

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

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

const url = '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings';
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}}/devices/:serial/camera/qualityAndRetentionSettings"]
                                                       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}}/devices/:serial/camera/qualityAndRetentionSettings" in

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

 "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings",
  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}}/devices/:serial/camera/qualityAndRetentionSettings');

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/devices/:serial/camera/qualityAndRetentionSettings")

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

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

import requests

url = "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")

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/devices/:serial/camera/qualityAndRetentionSettings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink"

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}}/networks/:networkId/cameras/:serial/videoLink"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink"

	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/networks/:networkId/cameras/:serial/videoLink HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink"))
    .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}}/networks/:networkId/cameras/:serial/videoLink")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink")
  .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}}/networks/:networkId/cameras/:serial/videoLink');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink'
};

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

const url = '{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink';
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}}/networks/:networkId/cameras/:serial/videoLink',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink');

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}}/networks/:networkId/cameras/:serial/videoLink'
};

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

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

const url = '{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink';
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}}/networks/:networkId/cameras/:serial/videoLink"]
                                                       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}}/networks/:networkId/cameras/:serial/videoLink" in

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

 "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink",
  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}}/networks/:networkId/cameras/:serial/videoLink');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/cameras/:serial/videoLink")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink")

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/networks/:networkId/cameras/:serial/videoLink') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/cameras/:serial/videoLink

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/cameras/:serial/videoLink

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/cameras/:serial/videoLink")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/camera/video/settings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/devices/:serial/camera/video/settings")

require "http/client"

url = "{{baseUrl}}/devices/:serial/camera/video/settings"

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}}/devices/:serial/camera/video/settings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/devices/:serial/camera/video/settings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/devices/:serial/camera/video/settings"

	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/devices/:serial/camera/video/settings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/devices/:serial/camera/video/settings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:serial/camera/video/settings"))
    .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}}/devices/:serial/camera/video/settings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/devices/:serial/camera/video/settings")
  .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}}/devices/:serial/camera/video/settings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/devices/:serial/camera/video/settings'
};

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

const url = '{{baseUrl}}/devices/:serial/camera/video/settings';
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}}/devices/:serial/camera/video/settings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/camera/video/settings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/devices/:serial/camera/video/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: 'GET',
  url: '{{baseUrl}}/devices/:serial/camera/video/settings'
};

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

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

const url = '{{baseUrl}}/devices/:serial/camera/video/settings';
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}}/devices/:serial/camera/video/settings"]
                                                       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}}/devices/:serial/camera/video/settings" in

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

 "{{baseUrl}}/devices/:serial/camera/video/settings",
  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}}/devices/:serial/camera/video/settings');

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/camera/video/settings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/devices/:serial/camera/video/settings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices/:serial/camera/video/settings' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/camera/video/settings' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/devices/:serial/camera/video/settings")

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

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

import requests

url = "{{baseUrl}}/devices/:serial/camera/video/settings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/camera/video/settings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/devices/:serial/camera/video/settings")

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/devices/:serial/camera/video/settings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/devices/:serial/camera/video/settings";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/devices/:serial/camera/video/settings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/devices/:serial/camera/video/settings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/devices/:serial/camera/video/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings");

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  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings" {:content-type :json
                                                                                              :form-params {:audioRecordingEnabled false
                                                                                                            :motionBasedRetentionEnabled false
                                                                                                            :motionDetectorVersion 0
                                                                                                            :profileId ""
                                                                                                            :quality ""
                                                                                                            :resolution ""
                                                                                                            :restrictedBandwidthModeEnabled false}})

require "http/client"

url = "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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}}/devices/:serial/camera/qualityAndRetentionSettings"),
    Content = new StringContent("{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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}}/devices/:serial/camera/qualityAndRetentionSettings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

	payload := strings.NewReader("{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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/devices/:serial/camera/qualityAndRetentionSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 205

{
  "audioRecordingEnabled": false,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "profileId": "",
  "quality": "",
  "resolution": "",
  "restrictedBandwidthModeEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")
  .header("content-type", "application/json")
  .body("{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  audioRecordingEnabled: false,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  profileId: '',
  quality: '',
  resolution: '',
  restrictedBandwidthModeEnabled: false
});

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

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

xhr.open('PUT', '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings',
  headers: {'content-type': 'application/json'},
  data: {
    audioRecordingEnabled: false,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    profileId: '',
    quality: '',
    resolution: '',
    restrictedBandwidthModeEnabled: false
  }
};

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

const url = '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"audioRecordingEnabled":false,"motionBasedRetentionEnabled":false,"motionDetectorVersion":0,"profileId":"","quality":"","resolution":"","restrictedBandwidthModeEnabled":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "audioRecordingEnabled": false,\n  "motionBasedRetentionEnabled": false,\n  "motionDetectorVersion": 0,\n  "profileId": "",\n  "quality": "",\n  "resolution": "",\n  "restrictedBandwidthModeEnabled": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings")
  .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/devices/:serial/camera/qualityAndRetentionSettings',
  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({
  audioRecordingEnabled: false,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  profileId: '',
  quality: '',
  resolution: '',
  restrictedBandwidthModeEnabled: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings',
  headers: {'content-type': 'application/json'},
  body: {
    audioRecordingEnabled: false,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    profileId: '',
    quality: '',
    resolution: '',
    restrictedBandwidthModeEnabled: false
  },
  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}}/devices/:serial/camera/qualityAndRetentionSettings');

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

req.type('json');
req.send({
  audioRecordingEnabled: false,
  motionBasedRetentionEnabled: false,
  motionDetectorVersion: 0,
  profileId: '',
  quality: '',
  resolution: '',
  restrictedBandwidthModeEnabled: false
});

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}}/devices/:serial/camera/qualityAndRetentionSettings',
  headers: {'content-type': 'application/json'},
  data: {
    audioRecordingEnabled: false,
    motionBasedRetentionEnabled: false,
    motionDetectorVersion: 0,
    profileId: '',
    quality: '',
    resolution: '',
    restrictedBandwidthModeEnabled: false
  }
};

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

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

const url = '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"audioRecordingEnabled":false,"motionBasedRetentionEnabled":false,"motionDetectorVersion":0,"profileId":"","quality":"","resolution":"","restrictedBandwidthModeEnabled":false}'
};

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 = @{ @"audioRecordingEnabled": @NO,
                              @"motionBasedRetentionEnabled": @NO,
                              @"motionDetectorVersion": @0,
                              @"profileId": @"",
                              @"quality": @"",
                              @"resolution": @"",
                              @"restrictedBandwidthModeEnabled": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"]
                                                       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}}/devices/:serial/camera/qualityAndRetentionSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}" in

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

 "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings",
  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([
    'audioRecordingEnabled' => null,
    'motionBasedRetentionEnabled' => null,
    'motionDetectorVersion' => 0,
    'profileId' => '',
    'quality' => '',
    'resolution' => '',
    'restrictedBandwidthModeEnabled' => null
  ]),
  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}}/devices/:serial/camera/qualityAndRetentionSettings', [
  'body' => '{
  "audioRecordingEnabled": false,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "profileId": "",
  "quality": "",
  "resolution": "",
  "restrictedBandwidthModeEnabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'audioRecordingEnabled' => null,
  'motionBasedRetentionEnabled' => null,
  'motionDetectorVersion' => 0,
  'profileId' => '',
  'quality' => '',
  'resolution' => '',
  'restrictedBandwidthModeEnabled' => null
]));

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

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

append(json_encode([
  'audioRecordingEnabled' => null,
  'motionBasedRetentionEnabled' => null,
  'motionDetectorVersion' => 0,
  'profileId' => '',
  'quality' => '',
  'resolution' => '',
  'restrictedBandwidthModeEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings');
$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}}/devices/:serial/camera/qualityAndRetentionSettings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "audioRecordingEnabled": false,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "profileId": "",
  "quality": "",
  "resolution": "",
  "restrictedBandwidthModeEnabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "audioRecordingEnabled": false,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "profileId": "",
  "quality": "",
  "resolution": "",
  "restrictedBandwidthModeEnabled": false
}'

import http.client

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

payload = "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\n}"

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

conn.request("PUT", "/baseUrl/devices/:serial/camera/qualityAndRetentionSettings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

payload = {
    "audioRecordingEnabled": False,
    "motionBasedRetentionEnabled": False,
    "motionDetectorVersion": 0,
    "profileId": "",
    "quality": "",
    "resolution": "",
    "restrictedBandwidthModeEnabled": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings"

payload <- "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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}}/devices/:serial/camera/qualityAndRetentionSettings")

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  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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/devices/:serial/camera/qualityAndRetentionSettings') do |req|
  req.body = "{\n  \"audioRecordingEnabled\": false,\n  \"motionBasedRetentionEnabled\": false,\n  \"motionDetectorVersion\": 0,\n  \"profileId\": \"\",\n  \"quality\": \"\",\n  \"resolution\": \"\",\n  \"restrictedBandwidthModeEnabled\": false\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}}/devices/:serial/camera/qualityAndRetentionSettings";

    let payload = json!({
        "audioRecordingEnabled": false,
        "motionBasedRetentionEnabled": false,
        "motionDetectorVersion": 0,
        "profileId": "",
        "quality": "",
        "resolution": "",
        "restrictedBandwidthModeEnabled": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "audioRecordingEnabled": false,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "profileId": "",
  "quality": "",
  "resolution": "",
  "restrictedBandwidthModeEnabled": false
}' |  \
  http PUT {{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "audioRecordingEnabled": false,\n  "motionBasedRetentionEnabled": false,\n  "motionDetectorVersion": 0,\n  "profileId": "",\n  "quality": "",\n  "resolution": "",\n  "restrictedBandwidthModeEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/devices/:serial/camera/qualityAndRetentionSettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "audioRecordingEnabled": false,
  "motionBasedRetentionEnabled": false,
  "motionDetectorVersion": 0,
  "profileId": "",
  "quality": "",
  "resolution": "",
  "restrictedBandwidthModeEnabled": false
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/camera/video/settings");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/devices/:serial/camera/video/settings" {:content-type :json
                                                                                 :form-params {:externalRtspEnabled false}})

require "http/client"

url = "{{baseUrl}}/devices/:serial/camera/video/settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"externalRtspEnabled\": false\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}}/devices/:serial/camera/video/settings"),
    Content = new StringContent("{\n  \"externalRtspEnabled\": false\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}}/devices/:serial/camera/video/settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"externalRtspEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/devices/:serial/camera/video/settings"

	payload := strings.NewReader("{\n  \"externalRtspEnabled\": false\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/devices/:serial/camera/video/settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "externalRtspEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/devices/:serial/camera/video/settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"externalRtspEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:serial/camera/video/settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"externalRtspEnabled\": false\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  \"externalRtspEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:serial/camera/video/settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/devices/:serial/camera/video/settings")
  .header("content-type", "application/json")
  .body("{\n  \"externalRtspEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  externalRtspEnabled: false
});

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

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

xhr.open('PUT', '{{baseUrl}}/devices/:serial/camera/video/settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:serial/camera/video/settings',
  headers: {'content-type': 'application/json'},
  data: {externalRtspEnabled: false}
};

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

const url = '{{baseUrl}}/devices/:serial/camera/video/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"externalRtspEnabled":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:serial/camera/video/settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "externalRtspEnabled": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"externalRtspEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/camera/video/settings")
  .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/devices/:serial/camera/video/settings',
  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({externalRtspEnabled: false}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:serial/camera/video/settings',
  headers: {'content-type': 'application/json'},
  body: {externalRtspEnabled: false},
  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}}/devices/:serial/camera/video/settings');

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

req.type('json');
req.send({
  externalRtspEnabled: false
});

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}}/devices/:serial/camera/video/settings',
  headers: {'content-type': 'application/json'},
  data: {externalRtspEnabled: false}
};

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

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

const url = '{{baseUrl}}/devices/:serial/camera/video/settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"externalRtspEnabled":false}'
};

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

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

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

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

 "{{baseUrl}}/devices/:serial/camera/video/settings",
  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([
    'externalRtspEnabled' => null
  ]),
  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}}/devices/:serial/camera/video/settings', [
  'body' => '{
  "externalRtspEnabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/camera/video/settings');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'externalRtspEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/devices/:serial/camera/video/settings');
$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}}/devices/:serial/camera/video/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "externalRtspEnabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/camera/video/settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "externalRtspEnabled": false
}'

import http.client

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

payload = "{\n  \"externalRtspEnabled\": false\n}"

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

conn.request("PUT", "/baseUrl/devices/:serial/camera/video/settings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/devices/:serial/camera/video/settings"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/camera/video/settings"

payload <- "{\n  \"externalRtspEnabled\": false\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}}/devices/:serial/camera/video/settings")

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  \"externalRtspEnabled\": false\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/devices/:serial/camera/video/settings') do |req|
  req.body = "{\n  \"externalRtspEnabled\": false\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}}/devices/:serial/camera/video/settings";

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

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

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

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

    dbg!(results);
}

echo '{
  "externalRtspEnabled": false
}' |  \
  http PUT {{baseUrl}}/devices/:serial/camera/video/settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "externalRtspEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/devices/:serial/camera/video/settings

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/devices/:serial/camera/video/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/configurationChanges");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/organizations/:organizationId/configurationChanges")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/configurationChanges"

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

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/configurationChanges");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/configurationChanges"

	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/organizations/:organizationId/configurationChanges HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/organizations/:organizationId/configurationChanges'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/configurationChanges")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/organizations/:organizationId/configurationChanges');

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}}/organizations/:organizationId/configurationChanges'
};

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

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

const url = '{{baseUrl}}/organizations/:organizationId/configurationChanges';
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}}/organizations/:organizationId/configurationChanges"]
                                                       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}}/organizations/:organizationId/configurationChanges" in

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

 "{{baseUrl}}/organizations/:organizationId/configurationChanges",
  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}}/organizations/:organizationId/configurationChanges');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/configurationChanges');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/organizations/:organizationId/configurationChanges');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/configurationChanges' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/configurationChanges' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/organizations/:organizationId/configurationChanges")

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

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

import requests

url = "{{baseUrl}}/organizations/:organizationId/configurationChanges"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/configurationChanges"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/configurationChanges")

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/organizations/:organizationId/configurationChanges') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/organizations/:organizationId/configurationChanges

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/configurationChanges

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/clients");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/devices/:serial/clients")

require "http/client"

url = "{{baseUrl}}/devices/:serial/clients"

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

var client = new RestClient("{{baseUrl}}/devices/:serial/clients");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/devices/:serial/clients"

	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/devices/:serial/clients HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/devices/:serial/clients'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/clients")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/devices/:serial/clients');

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}}/devices/:serial/clients'};

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

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

const url = '{{baseUrl}}/devices/:serial/clients';
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}}/devices/:serial/clients"]
                                                       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}}/devices/:serial/clients" in

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

 "{{baseUrl}}/devices/:serial/clients",
  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}}/devices/:serial/clients');

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/clients');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/devices/:serial/clients');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices/:serial/clients' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/clients' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/devices/:serial/clients")

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

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

import requests

url = "{{baseUrl}}/devices/:serial/clients"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/clients"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/devices/:serial/clients")

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/devices/:serial/clients') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/devices/:serial/clients

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/devices/:serial/clients

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/networks/:networkId/clients")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients"

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

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients"

	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/networks/:networkId/clients HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/networks/:networkId/clients'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients');

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}}/networks/:networkId/clients'};

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

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

const url = '{{baseUrl}}/networks/:networkId/clients';
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}}/networks/:networkId/clients"]
                                                       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}}/networks/:networkId/clients" in

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

 "{{baseUrl}}/networks/:networkId/clients",
  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}}/networks/:networkId/clients');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/networks/:networkId/clients');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/networks/:networkId/clients")

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

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

import requests

url = "{{baseUrl}}/networks/:networkId/clients"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients")

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/networks/:networkId/clients') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/provision");

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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/networks/:networkId/clients/provision" {:content-type :json
                                                                                  :form-params {:devicePolicy ""
                                                                                                :groupPolicyId ""
                                                                                                :mac ""
                                                                                                :name ""
                                                                                                :policiesBySecurityAppliance {:devicePolicy ""}
                                                                                                :policiesBySsid {:0 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :1 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :2 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :3 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :4 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :5 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :6 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :7 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :8 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :9 {:devicePolicy ""
                                                                                                                     :groupPolicyId ""}
                                                                                                                 :10 {:devicePolicy ""
                                                                                                                      :groupPolicyId ""}
                                                                                                                 :11 {:devicePolicy ""
                                                                                                                      :groupPolicyId ""}
                                                                                                                 :12 {:devicePolicy ""
                                                                                                                      :groupPolicyId ""}
                                                                                                                 :13 {:devicePolicy ""
                                                                                                                      :groupPolicyId ""}
                                                                                                                 :14 {:devicePolicy ""
                                                                                                                      :groupPolicyId ""}}}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/provision"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/provision"),
    Content = new StringContent("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/provision");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/provision"

	payload := strings.NewReader("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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/networks/:networkId/clients/provision HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1218

{
  "devicePolicy": "",
  "groupPolicyId": "",
  "mac": "",
  "name": "",
  "policiesBySecurityAppliance": {
    "devicePolicy": ""
  },
  "policiesBySsid": {
    "0": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "1": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "2": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "3": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "4": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "5": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "6": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "7": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "8": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "9": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "10": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "11": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "12": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "13": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "14": {
      "devicePolicy": "",
      "groupPolicyId": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/networks/:networkId/clients/provision")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/provision"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/provision")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/networks/:networkId/clients/provision")
  .header("content-type", "application/json")
  .body("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  devicePolicy: '',
  groupPolicyId: '',
  mac: '',
  name: '',
  policiesBySecurityAppliance: {
    devicePolicy: ''
  },
  policiesBySsid: {
    '0': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '1': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '2': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '3': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '4': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '5': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '6': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '7': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '8': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '9': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '10': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '11': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '12': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '13': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '14': {
      devicePolicy: '',
      groupPolicyId: ''
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/networks/:networkId/clients/provision');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/clients/provision',
  headers: {'content-type': 'application/json'},
  data: {
    devicePolicy: '',
    groupPolicyId: '',
    mac: '',
    name: '',
    policiesBySecurityAppliance: {devicePolicy: ''},
    policiesBySsid: {
      '0': {devicePolicy: '', groupPolicyId: ''},
      '1': {devicePolicy: '', groupPolicyId: ''},
      '2': {devicePolicy: '', groupPolicyId: ''},
      '3': {devicePolicy: '', groupPolicyId: ''},
      '4': {devicePolicy: '', groupPolicyId: ''},
      '5': {devicePolicy: '', groupPolicyId: ''},
      '6': {devicePolicy: '', groupPolicyId: ''},
      '7': {devicePolicy: '', groupPolicyId: ''},
      '8': {devicePolicy: '', groupPolicyId: ''},
      '9': {devicePolicy: '', groupPolicyId: ''},
      '10': {devicePolicy: '', groupPolicyId: ''},
      '11': {devicePolicy: '', groupPolicyId: ''},
      '12': {devicePolicy: '', groupPolicyId: ''},
      '13': {devicePolicy: '', groupPolicyId: ''},
      '14': {devicePolicy: '', groupPolicyId: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/provision';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"devicePolicy":"","groupPolicyId":"","mac":"","name":"","policiesBySecurityAppliance":{"devicePolicy":""},"policiesBySsid":{"0":{"devicePolicy":"","groupPolicyId":""},"1":{"devicePolicy":"","groupPolicyId":""},"2":{"devicePolicy":"","groupPolicyId":""},"3":{"devicePolicy":"","groupPolicyId":""},"4":{"devicePolicy":"","groupPolicyId":""},"5":{"devicePolicy":"","groupPolicyId":""},"6":{"devicePolicy":"","groupPolicyId":""},"7":{"devicePolicy":"","groupPolicyId":""},"8":{"devicePolicy":"","groupPolicyId":""},"9":{"devicePolicy":"","groupPolicyId":""},"10":{"devicePolicy":"","groupPolicyId":""},"11":{"devicePolicy":"","groupPolicyId":""},"12":{"devicePolicy":"","groupPolicyId":""},"13":{"devicePolicy":"","groupPolicyId":""},"14":{"devicePolicy":"","groupPolicyId":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/clients/provision',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "devicePolicy": "",\n  "groupPolicyId": "",\n  "mac": "",\n  "name": "",\n  "policiesBySecurityAppliance": {\n    "devicePolicy": ""\n  },\n  "policiesBySsid": {\n    "0": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "1": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "2": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "3": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "4": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "5": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "6": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "7": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "8": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "9": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "10": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "11": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "12": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "13": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "14": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/provision")
  .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/networks/:networkId/clients/provision',
  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({
  devicePolicy: '',
  groupPolicyId: '',
  mac: '',
  name: '',
  policiesBySecurityAppliance: {devicePolicy: ''},
  policiesBySsid: {
    '0': {devicePolicy: '', groupPolicyId: ''},
    '1': {devicePolicy: '', groupPolicyId: ''},
    '2': {devicePolicy: '', groupPolicyId: ''},
    '3': {devicePolicy: '', groupPolicyId: ''},
    '4': {devicePolicy: '', groupPolicyId: ''},
    '5': {devicePolicy: '', groupPolicyId: ''},
    '6': {devicePolicy: '', groupPolicyId: ''},
    '7': {devicePolicy: '', groupPolicyId: ''},
    '8': {devicePolicy: '', groupPolicyId: ''},
    '9': {devicePolicy: '', groupPolicyId: ''},
    '10': {devicePolicy: '', groupPolicyId: ''},
    '11': {devicePolicy: '', groupPolicyId: ''},
    '12': {devicePolicy: '', groupPolicyId: ''},
    '13': {devicePolicy: '', groupPolicyId: ''},
    '14': {devicePolicy: '', groupPolicyId: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/clients/provision',
  headers: {'content-type': 'application/json'},
  body: {
    devicePolicy: '',
    groupPolicyId: '',
    mac: '',
    name: '',
    policiesBySecurityAppliance: {devicePolicy: ''},
    policiesBySsid: {
      '0': {devicePolicy: '', groupPolicyId: ''},
      '1': {devicePolicy: '', groupPolicyId: ''},
      '2': {devicePolicy: '', groupPolicyId: ''},
      '3': {devicePolicy: '', groupPolicyId: ''},
      '4': {devicePolicy: '', groupPolicyId: ''},
      '5': {devicePolicy: '', groupPolicyId: ''},
      '6': {devicePolicy: '', groupPolicyId: ''},
      '7': {devicePolicy: '', groupPolicyId: ''},
      '8': {devicePolicy: '', groupPolicyId: ''},
      '9': {devicePolicy: '', groupPolicyId: ''},
      '10': {devicePolicy: '', groupPolicyId: ''},
      '11': {devicePolicy: '', groupPolicyId: ''},
      '12': {devicePolicy: '', groupPolicyId: ''},
      '13': {devicePolicy: '', groupPolicyId: ''},
      '14': {devicePolicy: '', groupPolicyId: ''}
    }
  },
  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}}/networks/:networkId/clients/provision');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  devicePolicy: '',
  groupPolicyId: '',
  mac: '',
  name: '',
  policiesBySecurityAppliance: {
    devicePolicy: ''
  },
  policiesBySsid: {
    '0': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '1': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '2': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '3': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '4': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '5': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '6': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '7': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '8': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '9': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '10': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '11': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '12': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '13': {
      devicePolicy: '',
      groupPolicyId: ''
    },
    '14': {
      devicePolicy: '',
      groupPolicyId: ''
    }
  }
});

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}}/networks/:networkId/clients/provision',
  headers: {'content-type': 'application/json'},
  data: {
    devicePolicy: '',
    groupPolicyId: '',
    mac: '',
    name: '',
    policiesBySecurityAppliance: {devicePolicy: ''},
    policiesBySsid: {
      '0': {devicePolicy: '', groupPolicyId: ''},
      '1': {devicePolicy: '', groupPolicyId: ''},
      '2': {devicePolicy: '', groupPolicyId: ''},
      '3': {devicePolicy: '', groupPolicyId: ''},
      '4': {devicePolicy: '', groupPolicyId: ''},
      '5': {devicePolicy: '', groupPolicyId: ''},
      '6': {devicePolicy: '', groupPolicyId: ''},
      '7': {devicePolicy: '', groupPolicyId: ''},
      '8': {devicePolicy: '', groupPolicyId: ''},
      '9': {devicePolicy: '', groupPolicyId: ''},
      '10': {devicePolicy: '', groupPolicyId: ''},
      '11': {devicePolicy: '', groupPolicyId: ''},
      '12': {devicePolicy: '', groupPolicyId: ''},
      '13': {devicePolicy: '', groupPolicyId: ''},
      '14': {devicePolicy: '', groupPolicyId: ''}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/provision';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"devicePolicy":"","groupPolicyId":"","mac":"","name":"","policiesBySecurityAppliance":{"devicePolicy":""},"policiesBySsid":{"0":{"devicePolicy":"","groupPolicyId":""},"1":{"devicePolicy":"","groupPolicyId":""},"2":{"devicePolicy":"","groupPolicyId":""},"3":{"devicePolicy":"","groupPolicyId":""},"4":{"devicePolicy":"","groupPolicyId":""},"5":{"devicePolicy":"","groupPolicyId":""},"6":{"devicePolicy":"","groupPolicyId":""},"7":{"devicePolicy":"","groupPolicyId":""},"8":{"devicePolicy":"","groupPolicyId":""},"9":{"devicePolicy":"","groupPolicyId":""},"10":{"devicePolicy":"","groupPolicyId":""},"11":{"devicePolicy":"","groupPolicyId":""},"12":{"devicePolicy":"","groupPolicyId":""},"13":{"devicePolicy":"","groupPolicyId":""},"14":{"devicePolicy":"","groupPolicyId":""}}}'
};

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 = @{ @"devicePolicy": @"",
                              @"groupPolicyId": @"",
                              @"mac": @"",
                              @"name": @"",
                              @"policiesBySecurityAppliance": @{ @"devicePolicy": @"" },
                              @"policiesBySsid": @{ @"0": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"1": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"2": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"3": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"4": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"5": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"6": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"7": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"8": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"9": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"10": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"11": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"12": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"13": @{ @"devicePolicy": @"", @"groupPolicyId": @"" }, @"14": @{ @"devicePolicy": @"", @"groupPolicyId": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/clients/provision"]
                                                       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}}/networks/:networkId/clients/provision" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/provision",
  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([
    'devicePolicy' => '',
    'groupPolicyId' => '',
    'mac' => '',
    'name' => '',
    'policiesBySecurityAppliance' => [
        'devicePolicy' => ''
    ],
    'policiesBySsid' => [
        '0' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '1' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '2' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '3' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '4' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '5' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '6' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '7' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '8' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '9' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '10' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '11' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '12' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '13' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ],
        '14' => [
                'devicePolicy' => '',
                'groupPolicyId' => ''
        ]
    ]
  ]),
  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}}/networks/:networkId/clients/provision', [
  'body' => '{
  "devicePolicy": "",
  "groupPolicyId": "",
  "mac": "",
  "name": "",
  "policiesBySecurityAppliance": {
    "devicePolicy": ""
  },
  "policiesBySsid": {
    "0": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "1": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "2": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "3": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "4": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "5": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "6": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "7": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "8": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "9": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "10": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "11": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "12": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "13": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "14": {
      "devicePolicy": "",
      "groupPolicyId": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/provision');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'devicePolicy' => '',
  'groupPolicyId' => '',
  'mac' => '',
  'name' => '',
  'policiesBySecurityAppliance' => [
    'devicePolicy' => ''
  ],
  'policiesBySsid' => [
    '0' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '1' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '2' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '3' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '4' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '5' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '6' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '7' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '8' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '9' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '10' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '11' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '12' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '13' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '14' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'devicePolicy' => '',
  'groupPolicyId' => '',
  'mac' => '',
  'name' => '',
  'policiesBySecurityAppliance' => [
    'devicePolicy' => ''
  ],
  'policiesBySsid' => [
    '0' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '1' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '2' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '3' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '4' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '5' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '6' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '7' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '8' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '9' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '10' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '11' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '12' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '13' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ],
    '14' => [
        'devicePolicy' => '',
        'groupPolicyId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/clients/provision');
$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}}/networks/:networkId/clients/provision' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "devicePolicy": "",
  "groupPolicyId": "",
  "mac": "",
  "name": "",
  "policiesBySecurityAppliance": {
    "devicePolicy": ""
  },
  "policiesBySsid": {
    "0": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "1": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "2": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "3": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "4": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "5": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "6": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "7": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "8": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "9": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "10": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "11": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "12": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "13": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "14": {
      "devicePolicy": "",
      "groupPolicyId": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/provision' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "devicePolicy": "",
  "groupPolicyId": "",
  "mac": "",
  "name": "",
  "policiesBySecurityAppliance": {
    "devicePolicy": ""
  },
  "policiesBySsid": {
    "0": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "1": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "2": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "3": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "4": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "5": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "6": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "7": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "8": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "9": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "10": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "11": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "12": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "13": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "14": {
      "devicePolicy": "",
      "groupPolicyId": ""
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/networks/:networkId/clients/provision", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/provision"

payload = {
    "devicePolicy": "",
    "groupPolicyId": "",
    "mac": "",
    "name": "",
    "policiesBySecurityAppliance": { "devicePolicy": "" },
    "policiesBySsid": {
        "0": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "1": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "2": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "3": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "4": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "5": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "6": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "7": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "8": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "9": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "10": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "11": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "12": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "13": {
            "devicePolicy": "",
            "groupPolicyId": ""
        },
        "14": {
            "devicePolicy": "",
            "groupPolicyId": ""
        }
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/provision"

payload <- "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/provision")

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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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/networks/:networkId/clients/provision') do |req|
  req.body = "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\",\n  \"mac\": \"\",\n  \"name\": \"\",\n  \"policiesBySecurityAppliance\": {\n    \"devicePolicy\": \"\"\n  },\n  \"policiesBySsid\": {\n    \"0\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"1\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"2\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"3\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"4\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"5\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"6\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"7\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"8\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"9\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"10\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"11\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"12\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"13\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\n    },\n    \"14\": {\n      \"devicePolicy\": \"\",\n      \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/provision";

    let payload = json!({
        "devicePolicy": "",
        "groupPolicyId": "",
        "mac": "",
        "name": "",
        "policiesBySecurityAppliance": json!({"devicePolicy": ""}),
        "policiesBySsid": json!({
            "0": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "1": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "2": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "3": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "4": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "5": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "6": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "7": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "8": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "9": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "10": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "11": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "12": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "13": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            }),
            "14": json!({
                "devicePolicy": "",
                "groupPolicyId": ""
            })
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "devicePolicy": "",
  "groupPolicyId": "",
  "mac": "",
  "name": "",
  "policiesBySecurityAppliance": {
    "devicePolicy": ""
  },
  "policiesBySsid": {
    "0": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "1": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "2": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "3": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "4": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "5": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "6": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "7": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "8": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "9": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "10": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "11": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "12": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "13": {
      "devicePolicy": "",
      "groupPolicyId": ""
    },
    "14": {
      "devicePolicy": "",
      "groupPolicyId": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/networks/:networkId/clients/provision \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "devicePolicy": "",\n  "groupPolicyId": "",\n  "mac": "",\n  "name": "",\n  "policiesBySecurityAppliance": {\n    "devicePolicy": ""\n  },\n  "policiesBySsid": {\n    "0": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "1": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "2": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "3": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "4": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "5": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "6": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "7": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "8": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "9": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "10": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "11": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "12": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "13": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    },\n    "14": {\n      "devicePolicy": "",\n      "groupPolicyId": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/provision

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "devicePolicy": "",
  "groupPolicyId": "",
  "mac": "",
  "name": "",
  "policiesBySecurityAppliance": ["devicePolicy": ""],
  "policiesBySsid": [
    "0": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "1": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "2": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "3": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "4": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "5": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "6": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "7": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "8": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "9": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "10": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "11": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "12": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "13": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ],
    "14": [
      "devicePolicy": "",
      "groupPolicyId": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/provision")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/clients/:clientId")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId"

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}}/networks/:networkId/clients/:clientId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients/:clientId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId"

	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/networks/:networkId/clients/:clientId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/clients/:clientId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId"))
    .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}}/networks/:networkId/clients/:clientId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/clients/:clientId")
  .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}}/networks/:networkId/clients/:clientId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId';
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}}/networks/:networkId/clients/:clientId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/clients/:clientId',
  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}}/networks/:networkId/clients/:clientId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId');

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}}/networks/:networkId/clients/:clientId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId';
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}}/networks/:networkId/clients/:clientId"]
                                                       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}}/networks/:networkId/clients/:clientId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId",
  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}}/networks/:networkId/clients/:clientId');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/clients/:clientId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients/:clientId")

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/networks/:networkId/clients/:clientId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients/:clientId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients/:clientId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory"

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}}/networks/:networkId/clients/:clientId/usageHistory"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory"

	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/networks/:networkId/clients/:clientId/usageHistory HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory"))
    .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}}/networks/:networkId/clients/:clientId/usageHistory")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory")
  .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}}/networks/:networkId/clients/:clientId/usageHistory');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory';
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}}/networks/:networkId/clients/:clientId/usageHistory',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/clients/:clientId/usageHistory',
  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}}/networks/:networkId/clients/:clientId/usageHistory'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory');

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}}/networks/:networkId/clients/:clientId/usageHistory'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory';
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}}/networks/:networkId/clients/:clientId/usageHistory"]
                                                       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}}/networks/:networkId/clients/:clientId/usageHistory" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory",
  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}}/networks/:networkId/clients/:clientId/usageHistory');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/clients/:clientId/usageHistory")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory")

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/networks/:networkId/clients/:clientId/usageHistory') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/usageHistory")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/events");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/clients/:clientId/events")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/events"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/networks/:networkId/clients/:clientId/events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients/:clientId/events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/events"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/networks/:networkId/clients/:clientId/events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/clients/:clientId/events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/events"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/events")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/clients/:clientId/events")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/events');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/events'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/events';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/events',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/events")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/clients/:clientId/events',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/events'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/events');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/events'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/events';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/clients/:clientId/events"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/networks/:networkId/clients/:clientId/events" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/events');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/events');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/events' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/clients/:clientId/events")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/events"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients/:clientId/events")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/networks/:networkId/clients/:clientId/events') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients/:clientId/events";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients/:clientId/events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/events")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory"

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}}/networks/:networkId/clients/:clientId/latencyHistory"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory"

	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/networks/:networkId/clients/:clientId/latencyHistory HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory"))
    .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}}/networks/:networkId/clients/:clientId/latencyHistory")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory")
  .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}}/networks/:networkId/clients/:clientId/latencyHistory');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory';
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}}/networks/:networkId/clients/:clientId/latencyHistory',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/clients/:clientId/latencyHistory',
  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}}/networks/:networkId/clients/:clientId/latencyHistory'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory');

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}}/networks/:networkId/clients/:clientId/latencyHistory'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory';
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}}/networks/:networkId/clients/:clientId/latencyHistory"]
                                                       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}}/networks/:networkId/clients/:clientId/latencyHistory" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory",
  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}}/networks/:networkId/clients/:clientId/latencyHistory');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/clients/:clientId/latencyHistory")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory")

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/networks/:networkId/clients/:clientId/latencyHistory') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/latencyHistory")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/policy");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/clients/:clientId/policy")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

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}}/networks/:networkId/clients/:clientId/policy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients/:clientId/policy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

	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/networks/:networkId/clients/:clientId/policy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/policy"))
    .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}}/networks/:networkId/clients/:clientId/policy")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .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}}/networks/:networkId/clients/:clientId/policy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/policy'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/policy';
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}}/networks/:networkId/clients/:clientId/policy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/clients/:clientId/policy',
  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}}/networks/:networkId/clients/:clientId/policy'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/policy');

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}}/networks/:networkId/clients/:clientId/policy'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/policy';
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}}/networks/:networkId/clients/:clientId/policy"]
                                                       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}}/networks/:networkId/clients/:clientId/policy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/policy",
  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}}/networks/:networkId/clients/:clientId/policy');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/policy');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/policy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/policy' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/policy' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/clients/:clientId/policy")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients/:clientId/policy")

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/networks/:networkId/clients/:clientId/policy') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients/:clientId/policy";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients/:clientId/policy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/policy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/policy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

	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/networks/:networkId/clients/:clientId/splashAuthorizationStatus HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"))
    .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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus';
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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');

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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus';
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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"]
                                                       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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus",
  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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/clients/:clientId/splashAuthorizationStatus")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")

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/networks/:networkId/clients/:clientId/splashAuthorizationStatus') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus");

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  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus" {:content-type :json
                                                                                                           :form-params {:ssids {:0 {:isAuthorized false}
                                                                                                                                 :1 {:isAuthorized false}
                                                                                                                                 :2 {:isAuthorized false}
                                                                                                                                 :3 {:isAuthorized false}
                                                                                                                                 :4 {:isAuthorized false}
                                                                                                                                 :5 {:isAuthorized false}
                                                                                                                                 :6 {:isAuthorized false}
                                                                                                                                 :7 {:isAuthorized false}
                                                                                                                                 :8 {:isAuthorized false}
                                                                                                                                 :9 {:isAuthorized false}
                                                                                                                                 :10 {:isAuthorized false}
                                                                                                                                 :11 {:isAuthorized false}
                                                                                                                                 :12 {:isAuthorized false}
                                                                                                                                 :13 {:isAuthorized false}
                                                                                                                                 :14 {:isAuthorized false}}}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"),
    Content = new StringContent("{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

	payload := strings.NewReader("{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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/networks/:networkId/clients/:clientId/splashAuthorizationStatus HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 714

{
  "ssids": {
    "0": {
      "isAuthorized": false
    },
    "1": {
      "isAuthorized": false
    },
    "2": {
      "isAuthorized": false
    },
    "3": {
      "isAuthorized": false
    },
    "4": {
      "isAuthorized": false
    },
    "5": {
      "isAuthorized": false
    },
    "6": {
      "isAuthorized": false
    },
    "7": {
      "isAuthorized": false
    },
    "8": {
      "isAuthorized": false
    },
    "9": {
      "isAuthorized": false
    },
    "10": {
      "isAuthorized": false
    },
    "11": {
      "isAuthorized": false
    },
    "12": {
      "isAuthorized": false
    },
    "13": {
      "isAuthorized": false
    },
    "14": {
      "isAuthorized": false
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .header("content-type", "application/json")
  .body("{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  ssids: {
    '0': {
      isAuthorized: false
    },
    '1': {
      isAuthorized: false
    },
    '2': {
      isAuthorized: false
    },
    '3': {
      isAuthorized: false
    },
    '4': {
      isAuthorized: false
    },
    '5': {
      isAuthorized: false
    },
    '6': {
      isAuthorized: false
    },
    '7': {
      isAuthorized: false
    },
    '8': {
      isAuthorized: false
    },
    '9': {
      isAuthorized: false
    },
    '10': {
      isAuthorized: false
    },
    '11': {
      isAuthorized: false
    },
    '12': {
      isAuthorized: false
    },
    '13': {
      isAuthorized: false
    },
    '14': {
      isAuthorized: false
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  headers: {'content-type': 'application/json'},
  data: {
    ssids: {
      '0': {isAuthorized: false},
      '1': {isAuthorized: false},
      '2': {isAuthorized: false},
      '3': {isAuthorized: false},
      '4': {isAuthorized: false},
      '5': {isAuthorized: false},
      '6': {isAuthorized: false},
      '7': {isAuthorized: false},
      '8': {isAuthorized: false},
      '9': {isAuthorized: false},
      '10': {isAuthorized: false},
      '11': {isAuthorized: false},
      '12': {isAuthorized: false},
      '13': {isAuthorized: false},
      '14': {isAuthorized: false}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ssids":{"0":{"isAuthorized":false},"1":{"isAuthorized":false},"2":{"isAuthorized":false},"3":{"isAuthorized":false},"4":{"isAuthorized":false},"5":{"isAuthorized":false},"6":{"isAuthorized":false},"7":{"isAuthorized":false},"8":{"isAuthorized":false},"9":{"isAuthorized":false},"10":{"isAuthorized":false},"11":{"isAuthorized":false},"12":{"isAuthorized":false},"13":{"isAuthorized":false},"14":{"isAuthorized":false}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ssids": {\n    "0": {\n      "isAuthorized": false\n    },\n    "1": {\n      "isAuthorized": false\n    },\n    "2": {\n      "isAuthorized": false\n    },\n    "3": {\n      "isAuthorized": false\n    },\n    "4": {\n      "isAuthorized": false\n    },\n    "5": {\n      "isAuthorized": false\n    },\n    "6": {\n      "isAuthorized": false\n    },\n    "7": {\n      "isAuthorized": false\n    },\n    "8": {\n      "isAuthorized": false\n    },\n    "9": {\n      "isAuthorized": false\n    },\n    "10": {\n      "isAuthorized": false\n    },\n    "11": {\n      "isAuthorized": false\n    },\n    "12": {\n      "isAuthorized": false\n    },\n    "13": {\n      "isAuthorized": false\n    },\n    "14": {\n      "isAuthorized": false\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  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")
  .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/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  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({
  ssids: {
    '0': {isAuthorized: false},
    '1': {isAuthorized: false},
    '2': {isAuthorized: false},
    '3': {isAuthorized: false},
    '4': {isAuthorized: false},
    '5': {isAuthorized: false},
    '6': {isAuthorized: false},
    '7': {isAuthorized: false},
    '8': {isAuthorized: false},
    '9': {isAuthorized: false},
    '10': {isAuthorized: false},
    '11': {isAuthorized: false},
    '12': {isAuthorized: false},
    '13': {isAuthorized: false},
    '14': {isAuthorized: false}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  headers: {'content-type': 'application/json'},
  body: {
    ssids: {
      '0': {isAuthorized: false},
      '1': {isAuthorized: false},
      '2': {isAuthorized: false},
      '3': {isAuthorized: false},
      '4': {isAuthorized: false},
      '5': {isAuthorized: false},
      '6': {isAuthorized: false},
      '7': {isAuthorized: false},
      '8': {isAuthorized: false},
      '9': {isAuthorized: false},
      '10': {isAuthorized: false},
      '11': {isAuthorized: false},
      '12': {isAuthorized: false},
      '13': {isAuthorized: false},
      '14': {isAuthorized: false}
    }
  },
  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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ssids: {
    '0': {
      isAuthorized: false
    },
    '1': {
      isAuthorized: false
    },
    '2': {
      isAuthorized: false
    },
    '3': {
      isAuthorized: false
    },
    '4': {
      isAuthorized: false
    },
    '5': {
      isAuthorized: false
    },
    '6': {
      isAuthorized: false
    },
    '7': {
      isAuthorized: false
    },
    '8': {
      isAuthorized: false
    },
    '9': {
      isAuthorized: false
    },
    '10': {
      isAuthorized: false
    },
    '11': {
      isAuthorized: false
    },
    '12': {
      isAuthorized: false
    },
    '13': {
      isAuthorized: false
    },
    '14': {
      isAuthorized: false
    }
  }
});

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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus',
  headers: {'content-type': 'application/json'},
  data: {
    ssids: {
      '0': {isAuthorized: false},
      '1': {isAuthorized: false},
      '2': {isAuthorized: false},
      '3': {isAuthorized: false},
      '4': {isAuthorized: false},
      '5': {isAuthorized: false},
      '6': {isAuthorized: false},
      '7': {isAuthorized: false},
      '8': {isAuthorized: false},
      '9': {isAuthorized: false},
      '10': {isAuthorized: false},
      '11': {isAuthorized: false},
      '12': {isAuthorized: false},
      '13': {isAuthorized: false},
      '14': {isAuthorized: false}
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ssids":{"0":{"isAuthorized":false},"1":{"isAuthorized":false},"2":{"isAuthorized":false},"3":{"isAuthorized":false},"4":{"isAuthorized":false},"5":{"isAuthorized":false},"6":{"isAuthorized":false},"7":{"isAuthorized":false},"8":{"isAuthorized":false},"9":{"isAuthorized":false},"10":{"isAuthorized":false},"11":{"isAuthorized":false},"12":{"isAuthorized":false},"13":{"isAuthorized":false},"14":{"isAuthorized":false}}}'
};

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 = @{ @"ssids": @{ @"0": @{ @"isAuthorized": @NO }, @"1": @{ @"isAuthorized": @NO }, @"2": @{ @"isAuthorized": @NO }, @"3": @{ @"isAuthorized": @NO }, @"4": @{ @"isAuthorized": @NO }, @"5": @{ @"isAuthorized": @NO }, @"6": @{ @"isAuthorized": @NO }, @"7": @{ @"isAuthorized": @NO }, @"8": @{ @"isAuthorized": @NO }, @"9": @{ @"isAuthorized": @NO }, @"10": @{ @"isAuthorized": @NO }, @"11": @{ @"isAuthorized": @NO }, @"12": @{ @"isAuthorized": @NO }, @"13": @{ @"isAuthorized": @NO }, @"14": @{ @"isAuthorized": @NO } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"]
                                                       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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus",
  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([
    'ssids' => [
        '0' => [
                'isAuthorized' => null
        ],
        '1' => [
                'isAuthorized' => null
        ],
        '2' => [
                'isAuthorized' => null
        ],
        '3' => [
                'isAuthorized' => null
        ],
        '4' => [
                'isAuthorized' => null
        ],
        '5' => [
                'isAuthorized' => null
        ],
        '6' => [
                'isAuthorized' => null
        ],
        '7' => [
                'isAuthorized' => null
        ],
        '8' => [
                'isAuthorized' => null
        ],
        '9' => [
                'isAuthorized' => null
        ],
        '10' => [
                'isAuthorized' => null
        ],
        '11' => [
                'isAuthorized' => null
        ],
        '12' => [
                'isAuthorized' => null
        ],
        '13' => [
                'isAuthorized' => null
        ],
        '14' => [
                'isAuthorized' => null
        ]
    ]
  ]),
  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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus', [
  'body' => '{
  "ssids": {
    "0": {
      "isAuthorized": false
    },
    "1": {
      "isAuthorized": false
    },
    "2": {
      "isAuthorized": false
    },
    "3": {
      "isAuthorized": false
    },
    "4": {
      "isAuthorized": false
    },
    "5": {
      "isAuthorized": false
    },
    "6": {
      "isAuthorized": false
    },
    "7": {
      "isAuthorized": false
    },
    "8": {
      "isAuthorized": false
    },
    "9": {
      "isAuthorized": false
    },
    "10": {
      "isAuthorized": false
    },
    "11": {
      "isAuthorized": false
    },
    "12": {
      "isAuthorized": false
    },
    "13": {
      "isAuthorized": false
    },
    "14": {
      "isAuthorized": false
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ssids' => [
    '0' => [
        'isAuthorized' => null
    ],
    '1' => [
        'isAuthorized' => null
    ],
    '2' => [
        'isAuthorized' => null
    ],
    '3' => [
        'isAuthorized' => null
    ],
    '4' => [
        'isAuthorized' => null
    ],
    '5' => [
        'isAuthorized' => null
    ],
    '6' => [
        'isAuthorized' => null
    ],
    '7' => [
        'isAuthorized' => null
    ],
    '8' => [
        'isAuthorized' => null
    ],
    '9' => [
        'isAuthorized' => null
    ],
    '10' => [
        'isAuthorized' => null
    ],
    '11' => [
        'isAuthorized' => null
    ],
    '12' => [
        'isAuthorized' => null
    ],
    '13' => [
        'isAuthorized' => null
    ],
    '14' => [
        'isAuthorized' => null
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ssids' => [
    '0' => [
        'isAuthorized' => null
    ],
    '1' => [
        'isAuthorized' => null
    ],
    '2' => [
        'isAuthorized' => null
    ],
    '3' => [
        'isAuthorized' => null
    ],
    '4' => [
        'isAuthorized' => null
    ],
    '5' => [
        'isAuthorized' => null
    ],
    '6' => [
        'isAuthorized' => null
    ],
    '7' => [
        'isAuthorized' => null
    ],
    '8' => [
        'isAuthorized' => null
    ],
    '9' => [
        'isAuthorized' => null
    ],
    '10' => [
        'isAuthorized' => null
    ],
    '11' => [
        'isAuthorized' => null
    ],
    '12' => [
        'isAuthorized' => null
    ],
    '13' => [
        'isAuthorized' => null
    ],
    '14' => [
        'isAuthorized' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus');
$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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ssids": {
    "0": {
      "isAuthorized": false
    },
    "1": {
      "isAuthorized": false
    },
    "2": {
      "isAuthorized": false
    },
    "3": {
      "isAuthorized": false
    },
    "4": {
      "isAuthorized": false
    },
    "5": {
      "isAuthorized": false
    },
    "6": {
      "isAuthorized": false
    },
    "7": {
      "isAuthorized": false
    },
    "8": {
      "isAuthorized": false
    },
    "9": {
      "isAuthorized": false
    },
    "10": {
      "isAuthorized": false
    },
    "11": {
      "isAuthorized": false
    },
    "12": {
      "isAuthorized": false
    },
    "13": {
      "isAuthorized": false
    },
    "14": {
      "isAuthorized": false
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ssids": {
    "0": {
      "isAuthorized": false
    },
    "1": {
      "isAuthorized": false
    },
    "2": {
      "isAuthorized": false
    },
    "3": {
      "isAuthorized": false
    },
    "4": {
      "isAuthorized": false
    },
    "5": {
      "isAuthorized": false
    },
    "6": {
      "isAuthorized": false
    },
    "7": {
      "isAuthorized": false
    },
    "8": {
      "isAuthorized": false
    },
    "9": {
      "isAuthorized": false
    },
    "10": {
      "isAuthorized": false
    },
    "11": {
      "isAuthorized": false
    },
    "12": {
      "isAuthorized": false
    },
    "13": {
      "isAuthorized": false
    },
    "14": {
      "isAuthorized": false
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/networks/:networkId/clients/:clientId/splashAuthorizationStatus", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

payload = { "ssids": {
        "0": { "isAuthorized": False },
        "1": { "isAuthorized": False },
        "2": { "isAuthorized": False },
        "3": { "isAuthorized": False },
        "4": { "isAuthorized": False },
        "5": { "isAuthorized": False },
        "6": { "isAuthorized": False },
        "7": { "isAuthorized": False },
        "8": { "isAuthorized": False },
        "9": { "isAuthorized": False },
        "10": { "isAuthorized": False },
        "11": { "isAuthorized": False },
        "12": { "isAuthorized": False },
        "13": { "isAuthorized": False },
        "14": { "isAuthorized": False }
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus"

payload <- "{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")

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  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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/networks/:networkId/clients/:clientId/splashAuthorizationStatus') do |req|
  req.body = "{\n  \"ssids\": {\n    \"0\": {\n      \"isAuthorized\": false\n    },\n    \"1\": {\n      \"isAuthorized\": false\n    },\n    \"2\": {\n      \"isAuthorized\": false\n    },\n    \"3\": {\n      \"isAuthorized\": false\n    },\n    \"4\": {\n      \"isAuthorized\": false\n    },\n    \"5\": {\n      \"isAuthorized\": false\n    },\n    \"6\": {\n      \"isAuthorized\": false\n    },\n    \"7\": {\n      \"isAuthorized\": false\n    },\n    \"8\": {\n      \"isAuthorized\": false\n    },\n    \"9\": {\n      \"isAuthorized\": false\n    },\n    \"10\": {\n      \"isAuthorized\": false\n    },\n    \"11\": {\n      \"isAuthorized\": false\n    },\n    \"12\": {\n      \"isAuthorized\": false\n    },\n    \"13\": {\n      \"isAuthorized\": false\n    },\n    \"14\": {\n      \"isAuthorized\": false\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}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus";

    let payload = json!({"ssids": json!({
            "0": json!({"isAuthorized": false}),
            "1": json!({"isAuthorized": false}),
            "2": json!({"isAuthorized": false}),
            "3": json!({"isAuthorized": false}),
            "4": json!({"isAuthorized": false}),
            "5": json!({"isAuthorized": false}),
            "6": json!({"isAuthorized": false}),
            "7": json!({"isAuthorized": false}),
            "8": json!({"isAuthorized": false}),
            "9": json!({"isAuthorized": false}),
            "10": json!({"isAuthorized": false}),
            "11": json!({"isAuthorized": false}),
            "12": json!({"isAuthorized": false}),
            "13": json!({"isAuthorized": false}),
            "14": json!({"isAuthorized": false})
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ssids": {
    "0": {
      "isAuthorized": false
    },
    "1": {
      "isAuthorized": false
    },
    "2": {
      "isAuthorized": false
    },
    "3": {
      "isAuthorized": false
    },
    "4": {
      "isAuthorized": false
    },
    "5": {
      "isAuthorized": false
    },
    "6": {
      "isAuthorized": false
    },
    "7": {
      "isAuthorized": false
    },
    "8": {
      "isAuthorized": false
    },
    "9": {
      "isAuthorized": false
    },
    "10": {
      "isAuthorized": false
    },
    "11": {
      "isAuthorized": false
    },
    "12": {
      "isAuthorized": false
    },
    "13": {
      "isAuthorized": false
    },
    "14": {
      "isAuthorized": false
    }
  }
}' |  \
  http PUT {{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ssids": {\n    "0": {\n      "isAuthorized": false\n    },\n    "1": {\n      "isAuthorized": false\n    },\n    "2": {\n      "isAuthorized": false\n    },\n    "3": {\n      "isAuthorized": false\n    },\n    "4": {\n      "isAuthorized": false\n    },\n    "5": {\n      "isAuthorized": false\n    },\n    "6": {\n      "isAuthorized": false\n    },\n    "7": {\n      "isAuthorized": false\n    },\n    "8": {\n      "isAuthorized": false\n    },\n    "9": {\n      "isAuthorized": false\n    },\n    "10": {\n      "isAuthorized": false\n    },\n    "11": {\n      "isAuthorized": false\n    },\n    "12": {\n      "isAuthorized": false\n    },\n    "13": {\n      "isAuthorized": false\n    },\n    "14": {\n      "isAuthorized": false\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ssids": [
    "0": ["isAuthorized": false],
    "1": ["isAuthorized": false],
    "2": ["isAuthorized": false],
    "3": ["isAuthorized": false],
    "4": ["isAuthorized": false],
    "5": ["isAuthorized": false],
    "6": ["isAuthorized": false],
    "7": ["isAuthorized": false],
    "8": ["isAuthorized": false],
    "9": ["isAuthorized": false],
    "10": ["isAuthorized": false],
    "11": ["isAuthorized": false],
    "12": ["isAuthorized": false],
    "13": ["isAuthorized": false],
    "14": ["isAuthorized": false]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/splashAuthorizationStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/clients/:clientId/policy");

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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/networks/:networkId/clients/:clientId/policy" {:content-type :json
                                                                                        :form-params {:devicePolicy ""
                                                                                                      :groupPolicyId ""}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/:clientId/policy"),
    Content = new StringContent("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/:clientId/policy");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

	payload := strings.NewReader("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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/networks/:networkId/clients/:clientId/policy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "devicePolicy": "",
  "groupPolicyId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/clients/:clientId/policy"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .header("content-type", "application/json")
  .body("{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  devicePolicy: '',
  groupPolicyId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/networks/:networkId/clients/:clientId/policy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/policy',
  headers: {'content-type': 'application/json'},
  data: {devicePolicy: '', groupPolicyId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/policy';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"devicePolicy":"","groupPolicyId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/policy',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "devicePolicy": "",\n  "groupPolicyId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/clients/:clientId/policy")
  .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/networks/:networkId/clients/:clientId/policy',
  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({devicePolicy: '', groupPolicyId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/clients/:clientId/policy',
  headers: {'content-type': 'application/json'},
  body: {devicePolicy: '', groupPolicyId: ''},
  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}}/networks/:networkId/clients/:clientId/policy');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  devicePolicy: '',
  groupPolicyId: ''
});

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}}/networks/:networkId/clients/:clientId/policy',
  headers: {'content-type': 'application/json'},
  data: {devicePolicy: '', groupPolicyId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/clients/:clientId/policy';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"devicePolicy":"","groupPolicyId":""}'
};

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 = @{ @"devicePolicy": @"",
                              @"groupPolicyId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/clients/:clientId/policy"]
                                                       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}}/networks/:networkId/clients/:clientId/policy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/clients/:clientId/policy",
  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([
    'devicePolicy' => '',
    'groupPolicyId' => ''
  ]),
  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}}/networks/:networkId/clients/:clientId/policy', [
  'body' => '{
  "devicePolicy": "",
  "groupPolicyId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/policy');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'devicePolicy' => '',
  'groupPolicyId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'devicePolicy' => '',
  'groupPolicyId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/clients/:clientId/policy');
$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}}/networks/:networkId/clients/:clientId/policy' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "devicePolicy": "",
  "groupPolicyId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/clients/:clientId/policy' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "devicePolicy": "",
  "groupPolicyId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/networks/:networkId/clients/:clientId/policy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

payload = {
    "devicePolicy": "",
    "groupPolicyId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/clients/:clientId/policy"

payload <- "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/:clientId/policy")

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  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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/networks/:networkId/clients/:clientId/policy') do |req|
  req.body = "{\n  \"devicePolicy\": \"\",\n  \"groupPolicyId\": \"\"\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}}/networks/:networkId/clients/:clientId/policy";

    let payload = json!({
        "devicePolicy": "",
        "groupPolicyId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "devicePolicy": "",
  "groupPolicyId": ""
}' |  \
  http PUT {{baseUrl}}/networks/:networkId/clients/:clientId/policy \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "devicePolicy": "",\n  "groupPolicyId": ""\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/clients/:clientId/policy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "devicePolicy": "",
  "groupPolicyId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/clients/:clientId/policy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/configTemplates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/organizations/:organizationId/configTemplates")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/configTemplates"

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}}/organizations/:organizationId/configTemplates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/configTemplates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/configTemplates"

	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/organizations/:organizationId/configTemplates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/organizations/:organizationId/configTemplates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/configTemplates"))
    .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}}/organizations/:organizationId/configTemplates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/organizations/:organizationId/configTemplates")
  .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}}/organizations/:organizationId/configTemplates');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/organizations/:organizationId/configTemplates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/organizations/:organizationId/configTemplates';
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}}/organizations/:organizationId/configTemplates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/configTemplates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/organizations/:organizationId/configTemplates',
  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}}/organizations/:organizationId/configTemplates'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/organizations/:organizationId/configTemplates');

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}}/organizations/:organizationId/configTemplates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/organizations/:organizationId/configTemplates';
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}}/organizations/:organizationId/configTemplates"]
                                                       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}}/organizations/:organizationId/configTemplates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/organizations/:organizationId/configTemplates",
  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}}/organizations/:organizationId/configTemplates');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/configTemplates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/organizations/:organizationId/configTemplates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/configTemplates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/configTemplates' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/organizations/:organizationId/configTemplates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/organizations/:organizationId/configTemplates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/configTemplates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/configTemplates")

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/organizations/:organizationId/configTemplates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/organizations/:organizationId/configTemplates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/organizations/:organizationId/configTemplates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/configTemplates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/:organizationId/configTemplates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId")

require "http/client"

url = "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId"

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}}/organizations/:organizationId/configTemplates/:configTemplateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId"

	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/organizations/:organizationId/configTemplates/:configTemplateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId"))
    .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}}/organizations/:organizationId/configTemplates/:configTemplateId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId")
  .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}}/organizations/:organizationId/configTemplates/:configTemplateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId';
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}}/organizations/:organizationId/configTemplates/:configTemplateId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/organizations/:organizationId/configTemplates/:configTemplateId',
  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}}/organizations/:organizationId/configTemplates/:configTemplateId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId');

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}}/organizations/:organizationId/configTemplates/:configTemplateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId';
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}}/organizations/:organizationId/configTemplates/:configTemplateId"]
                                                       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}}/organizations/:organizationId/configTemplates/:configTemplateId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId",
  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}}/organizations/:organizationId/configTemplates/:configTemplateId');

echo $response->getBody();

setUrl('{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/organizations/:organizationId/configTemplates/:configTemplateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId")

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/organizations/:organizationId/configTemplates/:configTemplateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organizations/:organizationId/configTemplates/:configTemplateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/contentFiltering/categories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/contentFiltering/categories")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/contentFiltering/categories"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/networks/:networkId/contentFiltering/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/contentFiltering/categories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/contentFiltering/categories"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/networks/:networkId/contentFiltering/categories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/contentFiltering/categories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/contentFiltering/categories"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/contentFiltering/categories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/contentFiltering/categories")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/networks/:networkId/contentFiltering/categories');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/contentFiltering/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/contentFiltering/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/contentFiltering/categories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/contentFiltering/categories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/contentFiltering/categories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/contentFiltering/categories'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/contentFiltering/categories');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/contentFiltering/categories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/contentFiltering/categories';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/contentFiltering/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/networks/:networkId/contentFiltering/categories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/contentFiltering/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/networks/:networkId/contentFiltering/categories');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/contentFiltering/categories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/contentFiltering/categories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/contentFiltering/categories' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/contentFiltering/categories' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/contentFiltering/categories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/contentFiltering/categories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/contentFiltering/categories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/contentFiltering/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/networks/:networkId/contentFiltering/categories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/contentFiltering/categories";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/contentFiltering/categories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/contentFiltering/categories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/contentFiltering/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/contentFiltering");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/contentFiltering")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/contentFiltering"

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}}/networks/:networkId/contentFiltering"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/contentFiltering");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/contentFiltering"

	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/networks/:networkId/contentFiltering HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/contentFiltering")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/contentFiltering"))
    .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}}/networks/:networkId/contentFiltering")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/contentFiltering")
  .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}}/networks/:networkId/contentFiltering');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/contentFiltering'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/contentFiltering';
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}}/networks/:networkId/contentFiltering',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/contentFiltering")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/contentFiltering',
  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}}/networks/:networkId/contentFiltering'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/contentFiltering');

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}}/networks/:networkId/contentFiltering'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/contentFiltering';
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}}/networks/:networkId/contentFiltering"]
                                                       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}}/networks/:networkId/contentFiltering" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/contentFiltering",
  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}}/networks/:networkId/contentFiltering');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/contentFiltering');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/contentFiltering');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/contentFiltering' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/contentFiltering' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/contentFiltering")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/contentFiltering"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/contentFiltering"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/contentFiltering")

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/networks/:networkId/contentFiltering') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/contentFiltering";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/networks/:networkId/contentFiltering

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/networks/:networkId/contentFiltering

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/contentFiltering")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/contentFiltering");

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  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/networks/:networkId/contentFiltering" {:content-type :json
                                                                                :form-params {:allowedUrlPatterns []
                                                                                              :blockedUrlCategories []
                                                                                              :blockedUrlPatterns []
                                                                                              :urlCategoryListSize ""}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/contentFiltering"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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}}/networks/:networkId/contentFiltering"),
    Content = new StringContent("{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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}}/networks/:networkId/contentFiltering");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/contentFiltering"

	payload := strings.NewReader("{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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/networks/:networkId/contentFiltering HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 117

{
  "allowedUrlPatterns": [],
  "blockedUrlCategories": [],
  "blockedUrlPatterns": [],
  "urlCategoryListSize": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/networks/:networkId/contentFiltering")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/contentFiltering"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/contentFiltering")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/networks/:networkId/contentFiltering")
  .header("content-type", "application/json")
  .body("{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  allowedUrlPatterns: [],
  blockedUrlCategories: [],
  blockedUrlPatterns: [],
  urlCategoryListSize: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/networks/:networkId/contentFiltering');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/contentFiltering',
  headers: {'content-type': 'application/json'},
  data: {
    allowedUrlPatterns: [],
    blockedUrlCategories: [],
    blockedUrlPatterns: [],
    urlCategoryListSize: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/contentFiltering';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"allowedUrlPatterns":[],"blockedUrlCategories":[],"blockedUrlPatterns":[],"urlCategoryListSize":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/contentFiltering',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allowedUrlPatterns": [],\n  "blockedUrlCategories": [],\n  "blockedUrlPatterns": [],\n  "urlCategoryListSize": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/contentFiltering")
  .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/networks/:networkId/contentFiltering',
  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({
  allowedUrlPatterns: [],
  blockedUrlCategories: [],
  blockedUrlPatterns: [],
  urlCategoryListSize: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/networks/:networkId/contentFiltering',
  headers: {'content-type': 'application/json'},
  body: {
    allowedUrlPatterns: [],
    blockedUrlCategories: [],
    blockedUrlPatterns: [],
    urlCategoryListSize: ''
  },
  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}}/networks/:networkId/contentFiltering');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  allowedUrlPatterns: [],
  blockedUrlCategories: [],
  blockedUrlPatterns: [],
  urlCategoryListSize: ''
});

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}}/networks/:networkId/contentFiltering',
  headers: {'content-type': 'application/json'},
  data: {
    allowedUrlPatterns: [],
    blockedUrlCategories: [],
    blockedUrlPatterns: [],
    urlCategoryListSize: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/contentFiltering';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"allowedUrlPatterns":[],"blockedUrlCategories":[],"blockedUrlPatterns":[],"urlCategoryListSize":""}'
};

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 = @{ @"allowedUrlPatterns": @[  ],
                              @"blockedUrlCategories": @[  ],
                              @"blockedUrlPatterns": @[  ],
                              @"urlCategoryListSize": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/contentFiltering"]
                                                       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}}/networks/:networkId/contentFiltering" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/contentFiltering",
  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([
    'allowedUrlPatterns' => [
        
    ],
    'blockedUrlCategories' => [
        
    ],
    'blockedUrlPatterns' => [
        
    ],
    'urlCategoryListSize' => ''
  ]),
  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}}/networks/:networkId/contentFiltering', [
  'body' => '{
  "allowedUrlPatterns": [],
  "blockedUrlCategories": [],
  "blockedUrlPatterns": [],
  "urlCategoryListSize": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/contentFiltering');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allowedUrlPatterns' => [
    
  ],
  'blockedUrlCategories' => [
    
  ],
  'blockedUrlPatterns' => [
    
  ],
  'urlCategoryListSize' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'allowedUrlPatterns' => [
    
  ],
  'blockedUrlCategories' => [
    
  ],
  'blockedUrlPatterns' => [
    
  ],
  'urlCategoryListSize' => ''
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/contentFiltering');
$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}}/networks/:networkId/contentFiltering' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "allowedUrlPatterns": [],
  "blockedUrlCategories": [],
  "blockedUrlPatterns": [],
  "urlCategoryListSize": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/contentFiltering' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "allowedUrlPatterns": [],
  "blockedUrlCategories": [],
  "blockedUrlPatterns": [],
  "urlCategoryListSize": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/networks/:networkId/contentFiltering", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/contentFiltering"

payload = {
    "allowedUrlPatterns": [],
    "blockedUrlCategories": [],
    "blockedUrlPatterns": [],
    "urlCategoryListSize": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/contentFiltering"

payload <- "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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}}/networks/:networkId/contentFiltering")

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  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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/networks/:networkId/contentFiltering') do |req|
  req.body = "{\n  \"allowedUrlPatterns\": [],\n  \"blockedUrlCategories\": [],\n  \"blockedUrlPatterns\": [],\n  \"urlCategoryListSize\": \"\"\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}}/networks/:networkId/contentFiltering";

    let payload = json!({
        "allowedUrlPatterns": (),
        "blockedUrlCategories": (),
        "blockedUrlPatterns": (),
        "urlCategoryListSize": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "allowedUrlPatterns": [],
  "blockedUrlCategories": [],
  "blockedUrlPatterns": [],
  "urlCategoryListSize": ""
}' |  \
  http PUT {{baseUrl}}/networks/:networkId/contentFiltering \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "allowedUrlPatterns": [],\n  "blockedUrlCategories": [],\n  "blockedUrlPatterns": [],\n  "urlCategoryListSize": ""\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/contentFiltering

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allowedUrlPatterns": [],
  "blockedUrlCategories": [],
  "blockedUrlPatterns": [],
  "urlCategoryListSize": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/contentFiltering")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/devices/claim");

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  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/networks/:networkId/devices/claim" {:content-type :json
                                                                              :form-params {:serials ["Q234-ABCD-0001" "Q234-ABCD-0002" "Q234-ABCD-0003"]}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/devices/claim"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\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}}/networks/:networkId/devices/claim"),
    Content = new StringContent("{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\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}}/networks/:networkId/devices/claim");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/devices/claim"

	payload := strings.NewReader("{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\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/networks/:networkId/devices/claim HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "serials": [
    "Q234-ABCD-0001",
    "Q234-ABCD-0002",
    "Q234-ABCD-0003"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/networks/:networkId/devices/claim")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/devices/claim"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\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  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/devices/claim")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/networks/:networkId/devices/claim")
  .header("content-type", "application/json")
  .body("{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  serials: [
    'Q234-ABCD-0001',
    'Q234-ABCD-0002',
    'Q234-ABCD-0003'
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/networks/:networkId/devices/claim');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/devices/claim',
  headers: {'content-type': 'application/json'},
  data: {serials: ['Q234-ABCD-0001', 'Q234-ABCD-0002', 'Q234-ABCD-0003']}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/devices/claim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"serials":["Q234-ABCD-0001","Q234-ABCD-0002","Q234-ABCD-0003"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/networks/:networkId/devices/claim',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serials": [\n    "Q234-ABCD-0001",\n    "Q234-ABCD-0002",\n    "Q234-ABCD-0003"\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  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/devices/claim")
  .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/networks/:networkId/devices/claim',
  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({serials: ['Q234-ABCD-0001', 'Q234-ABCD-0002', 'Q234-ABCD-0003']}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/networks/:networkId/devices/claim',
  headers: {'content-type': 'application/json'},
  body: {serials: ['Q234-ABCD-0001', 'Q234-ABCD-0002', 'Q234-ABCD-0003']},
  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}}/networks/:networkId/devices/claim');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  serials: [
    'Q234-ABCD-0001',
    'Q234-ABCD-0002',
    'Q234-ABCD-0003'
  ]
});

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}}/networks/:networkId/devices/claim',
  headers: {'content-type': 'application/json'},
  data: {serials: ['Q234-ABCD-0001', 'Q234-ABCD-0002', 'Q234-ABCD-0003']}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/devices/claim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"serials":["Q234-ABCD-0001","Q234-ABCD-0002","Q234-ABCD-0003"]}'
};

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 = @{ @"serials": @[ @"Q234-ABCD-0001", @"Q234-ABCD-0002", @"Q234-ABCD-0003" ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/networks/:networkId/devices/claim"]
                                                       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}}/networks/:networkId/devices/claim" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/devices/claim",
  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([
    'serials' => [
        'Q234-ABCD-0001',
        'Q234-ABCD-0002',
        'Q234-ABCD-0003'
    ]
  ]),
  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}}/networks/:networkId/devices/claim', [
  'body' => '{
  "serials": [
    "Q234-ABCD-0001",
    "Q234-ABCD-0002",
    "Q234-ABCD-0003"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/devices/claim');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serials' => [
    'Q234-ABCD-0001',
    'Q234-ABCD-0002',
    'Q234-ABCD-0003'
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'serials' => [
    'Q234-ABCD-0001',
    'Q234-ABCD-0002',
    'Q234-ABCD-0003'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/networks/:networkId/devices/claim');
$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}}/networks/:networkId/devices/claim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serials": [
    "Q234-ABCD-0001",
    "Q234-ABCD-0002",
    "Q234-ABCD-0003"
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/devices/claim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serials": [
    "Q234-ABCD-0001",
    "Q234-ABCD-0002",
    "Q234-ABCD-0003"
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/networks/:networkId/devices/claim", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/devices/claim"

payload = { "serials": ["Q234-ABCD-0001", "Q234-ABCD-0002", "Q234-ABCD-0003"] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/devices/claim"

payload <- "{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\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}}/networks/:networkId/devices/claim")

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  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\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/networks/:networkId/devices/claim') do |req|
  req.body = "{\n  \"serials\": [\n    \"Q234-ABCD-0001\",\n    \"Q234-ABCD-0002\",\n    \"Q234-ABCD-0003\"\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/devices/claim";

    let payload = json!({"serials": ("Q234-ABCD-0001", "Q234-ABCD-0002", "Q234-ABCD-0003")});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "serials": [
    "Q234-ABCD-0001",
    "Q234-ABCD-0002",
    "Q234-ABCD-0003"
  ]
}' |  \
  http POST {{baseUrl}}/networks/:networkId/devices/claim \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "serials": [\n    "Q234-ABCD-0001",\n    "Q234-ABCD-0002",\n    "Q234-ABCD-0003"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/networks/:networkId/devices/claim

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["serials": ["Q234-ABCD-0001", "Q234-ABCD-0002", "Q234-ABCD-0003"]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/devices/claim")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/devices/:serial/switch/ports/cycle");

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  \"ports\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/devices/:serial/switch/ports/cycle" {:content-type :json
                                                                               :form-params {:ports []}})

require "http/client"

url = "{{baseUrl}}/devices/:serial/switch/ports/cycle"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ports\": []\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}}/devices/:serial/switch/ports/cycle"),
    Content = new StringContent("{\n  \"ports\": []\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}}/devices/:serial/switch/ports/cycle");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ports\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/devices/:serial/switch/ports/cycle"

	payload := strings.NewReader("{\n  \"ports\": []\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/devices/:serial/switch/ports/cycle HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "ports": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/devices/:serial/switch/ports/cycle")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ports\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:serial/switch/ports/cycle"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ports\": []\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  \"ports\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:serial/switch/ports/cycle")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/devices/:serial/switch/ports/cycle")
  .header("content-type", "application/json")
  .body("{\n  \"ports\": []\n}")
  .asString();

const data = JSON.stringify({
  ports: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/devices/:serial/switch/ports/cycle');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/devices/:serial/switch/ports/cycle',
  headers: {'content-type': 'application/json'},
  data: {ports: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/devices/:serial/switch/ports/cycle';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ports":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:serial/switch/ports/cycle',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ports": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ports\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices/:serial/switch/ports/cycle")
  .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/devices/:serial/switch/ports/cycle',
  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({ports: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/devices/:serial/switch/ports/cycle',
  headers: {'content-type': 'application/json'},
  body: {ports: []},
  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}}/devices/:serial/switch/ports/cycle');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ports: []
});

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}}/devices/:serial/switch/ports/cycle',
  headers: {'content-type': 'application/json'},
  data: {ports: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/devices/:serial/switch/ports/cycle';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ports":[]}'
};

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 = @{ @"ports": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/devices/:serial/switch/ports/cycle"]
                                                       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}}/devices/:serial/switch/ports/cycle" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ports\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/devices/:serial/switch/ports/cycle",
  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([
    'ports' => [
        
    ]
  ]),
  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}}/devices/:serial/switch/ports/cycle', [
  'body' => '{
  "ports": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/devices/:serial/switch/ports/cycle');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ports' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ports' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/devices/:serial/switch/ports/cycle');
$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}}/devices/:serial/switch/ports/cycle' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ports": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:serial/switch/ports/cycle' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ports": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ports\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/devices/:serial/switch/ports/cycle", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/devices/:serial/switch/ports/cycle"

payload = { "ports": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/devices/:serial/switch/ports/cycle"

payload <- "{\n  \"ports\": []\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}}/devices/:serial/switch/ports/cycle")

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  \"ports\": []\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/devices/:serial/switch/ports/cycle') do |req|
  req.body = "{\n  \"ports\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/devices/:serial/switch/ports/cycle";

    let payload = json!({"ports": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ports": []
}' |  \
  http POST {{baseUrl}}/devices/:serial/switch/ports/cycle \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ports": []\n}' \
  --output-document \
  - {{baseUrl}}/devices/:serial/switch/ports/cycle

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ports": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/devices/:serial/switch/ports/cycle")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory" {:query-params {:ip ""}})

require "http/client"

url = "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip="

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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip="

	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/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip="))
    .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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")
  .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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory',
  params: {ip: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=';
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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=',
  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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory',
  qs: {ip: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory');

req.query({
  ip: ''
});

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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory',
  params: {ip: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=';
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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip="]
                                                       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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=",
  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}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=');

echo $response->getBody();

setUrl('{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'ip' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'ip' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory"

querystring = {"ip":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory"

queryString <- list(ip = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")

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/networks/:networkId/devices/:serial/lossAndLatencyHistory') do |req|
  req.params['ip'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory";

    let querystring = [
        ("ip", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/networks/:networkId/devices/:serial/lossAndLatencyHistory?ip=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/networks/:networkId/devices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/networks/:networkId/devices")

require "http/client"

url = "{{baseUrl}}/networks/:networkId/devices"

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}}/networks/:networkId/devices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/networks/:networkId/devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/networks/:networkId/devices"

	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/networks/:networkId/devices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/networks/:networkId/devices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/networks/:networkId/devices"))
    .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}}/networks/:networkId/devices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/networks/:networkId/devices")
  .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}}/networks/:networkId/devices');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/networks/:networkId/devices'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/networks/:networkId/devices';
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}}/networks/:networkId/devices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/networks/:networkId/devices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/networks/:networkId/devices',
  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();