CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/email-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/settings/email-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/email-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/email-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/email-service");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/email-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/admin/settings/email-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/settings/email-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/email-service"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/settings/email-service")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/admin/settings/email-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/email-service',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/email-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin/settings/email-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/email-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/email-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/email-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin/settings/email-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/email-service');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/email-service');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/email-service' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/email-service' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/admin/settings/email-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/email-service"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/email-service"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/email-service")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/admin/settings/email-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/email-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/admin/settings/email-service \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/email-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/email-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/sms-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/settings/sms-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/sms-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/sms-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/sms-service");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/sms-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/admin/settings/sms-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/settings/sms-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/sms-service"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/settings/sms-service")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/admin/settings/sms-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/sms-service',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/sms-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin/settings/sms-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/sms-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/sms-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/sms-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin/settings/sms-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/sms-service' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/sms-service' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/admin/settings/sms-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/sms-service"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/sms-service"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/sms-service")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/admin/settings/sms-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/sms-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/admin/settings/sms-service \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/sms-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/sms-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/sms-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/admin/settings/sms-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/sms-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/sms-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/sms-service");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/sms-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

DELETE /baseUrl/admin/settings/sms-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/admin/settings/sms-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/sms-service"))
    .header("clearblade-devtoken", "")
    .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}}/admin/settings/sms-service")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/settings/sms-service")
  .header("clearblade-devtoken", "")
  .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}}/admin/settings/sms-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/sms-service',
  method: 'DELETE',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/sms-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/admin/settings/sms-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/sms-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/sms-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/sms-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/admin/settings/sms-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/sms-service' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/sms-service' -Method DELETE -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("DELETE", "/baseUrl/admin/settings/sms-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/sms-service"

headers = {"clearblade-devtoken": ""}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/sms-service"

response <- VERB("DELETE", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/sms-service")

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

request = Net::HTTP::Delete.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/admin/settings/sms-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/sms-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/admin/settings/sms-service \
  clearblade-devtoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/sms-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/sms-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/email-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/admin/settings/email-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/email-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/email-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/email-service");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/email-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

DELETE /baseUrl/admin/settings/email-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/admin/settings/email-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/email-service"))
    .header("clearblade-devtoken", "")
    .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}}/admin/settings/email-service")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/admin/settings/email-service")
  .header("clearblade-devtoken", "")
  .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}}/admin/settings/email-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/email-service',
  method: 'DELETE',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/email-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/admin/settings/email-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/email-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/email-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/email-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/admin/settings/email-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/email-service');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/email-service');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/email-service' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/email-service' -Method DELETE -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("DELETE", "/baseUrl/admin/settings/email-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/email-service"

headers = {"clearblade-devtoken": ""}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/email-service"

response <- VERB("DELETE", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/email-service")

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

request = Net::HTTP::Delete.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/admin/settings/email-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/email-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/admin/settings/email-service \
  clearblade-devtoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/email-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/email-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/email-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/settings/email-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/email-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/email-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/email-service");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/email-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

GET /baseUrl/admin/settings/email-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/settings/email-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/email-service"))
    .header("clearblade-devtoken", "")
    .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}}/admin/settings/email-service")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/settings/email-service")
  .header("clearblade-devtoken", "")
  .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}}/admin/settings/email-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/email-service',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/email-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/settings/email-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/email-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/email-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/email-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin/settings/email-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/email-service');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/email-service');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/email-service' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/email-service' -Method GET -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/settings/email-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/email-service"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/email-service"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/email-service")

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

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/admin/settings/email-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/email-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/admin/settings/email-service \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/email-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/email-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/sms-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/settings/sms-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/sms-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/sms-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/sms-service");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/sms-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

GET /baseUrl/admin/settings/sms-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/settings/sms-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/sms-service"))
    .header("clearblade-devtoken", "")
    .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}}/admin/settings/sms-service")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/settings/sms-service")
  .header("clearblade-devtoken", "")
  .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}}/admin/settings/sms-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/sms-service',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/sms-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/settings/sms-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/sms-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/sms-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/sms-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin/settings/sms-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/sms-service' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/sms-service' -Method GET -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/settings/sms-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/sms-service"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/sms-service"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/sms-service")

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

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/admin/settings/sms-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/sms-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/admin/settings/sms-service \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/sms-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/sms-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/validate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/validate" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/validate"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/admin/validate");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/validate"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/admin/validate HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/validate")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/validate"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/validate")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/validate")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/admin/validate');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/validate',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/validate';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/validate',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/validate")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/validate',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/validate',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin/validate');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/validate',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/validate';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/validate" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/validate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin/validate', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/validate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/validate');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/validate' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/validate' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/admin/validate", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/validate"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/validate"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/validate")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/admin/validate') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/admin/validate \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/validate

import Foundation

let headers = ["clearblade-devtoken": ""]

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/email-service/test");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/settings/email-service/test" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/email-service/test"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/email-service/test"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/email-service/test");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/email-service/test"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/admin/settings/email-service/test HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/settings/email-service/test")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/email-service/test"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service/test")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/settings/email-service/test")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/admin/settings/email-service/test');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/email-service/test',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/email-service/test';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/email-service/test',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service/test")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/email-service/test',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/email-service/test',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin/settings/email-service/test');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/email-service/test',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/email-service/test';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/email-service/test"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/email-service/test" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/email-service/test",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin/settings/email-service/test', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/email-service/test');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/email-service/test');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/email-service/test' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/email-service/test' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/admin/settings/email-service/test", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/email-service/test"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/email-service/test"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/email-service/test")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/admin/settings/email-service/test') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/email-service/test";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/admin/settings/email-service/test \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/email-service/test

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/email-service/test")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/sms-service/test");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/admin/settings/sms-service/test" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/sms-service/test"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/sms-service/test"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/sms-service/test");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/sms-service/test"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/admin/settings/sms-service/test HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/settings/sms-service/test")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/sms-service/test"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service/test")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/admin/settings/sms-service/test")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/admin/settings/sms-service/test');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/sms-service/test',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/sms-service/test';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/sms-service/test',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service/test")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/sms-service/test',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/settings/sms-service/test',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin/settings/sms-service/test');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/sms-service/test',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/sms-service/test';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/sms-service/test"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/sms-service/test" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/sms-service/test",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/admin/settings/sms-service/test', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/sms-service/test');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/sms-service/test');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/sms-service/test' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/sms-service/test' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/admin/settings/sms-service/test", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/sms-service/test"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/sms-service/test"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/sms-service/test")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/admin/settings/sms-service/test') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/sms-service/test";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/admin/settings/sms-service/test \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/sms-service/test

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/sms-service/test")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/email-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/settings/email-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/email-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/email-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/email-service");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/email-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

PUT /baseUrl/admin/settings/email-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/settings/email-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/email-service"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/settings/email-service")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/admin/settings/email-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/email-service',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/email-service")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/email-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/admin/settings/email-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/email-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/email-service';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/email-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/email-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/email-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/admin/settings/email-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/email-service');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/email-service');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/email-service' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/email-service' -Method PUT -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/admin/settings/email-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/email-service"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/email-service"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/email-service")

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

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.put('/baseUrl/admin/settings/email-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/email-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/admin/settings/email-service \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/email-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/email-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/sms-service");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/settings/sms-service" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/sms-service"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/sms-service"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/sms-service");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/sms-service"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

PUT /baseUrl/admin/settings/sms-service HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/settings/sms-service")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/sms-service"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/settings/sms-service")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/admin/settings/sms-service');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/sms-service',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/sms-service")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/sms-service',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/admin/settings/sms-service');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/sms-service',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/sms-service';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/sms-service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/sms-service" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/sms-service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/admin/settings/sms-service', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/sms-service');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/sms-service' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/sms-service' -Method PUT -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/admin/settings/sms-service", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/sms-service"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/sms-service"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/sms-service")

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

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.put('/baseUrl/admin/settings/sms-service') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/settings/sms-service";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/admin/settings/sms-service \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/sms-service

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/sms-service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/security");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/settings/security" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/security"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/security"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/security");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/security"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

PUT /baseUrl/admin/settings/security HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/settings/security")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/security"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/settings/security")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/settings/security")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/admin/settings/security');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/settings/security',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/security';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/security',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/security")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/security',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/settings/security',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/admin/settings/security');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/security',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/security';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/security"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/security" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/security",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/admin/settings/security', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/security');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/security');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/security' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/security' -Method PUT -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/admin/settings/security", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/security"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/security"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/security")

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

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.put('/baseUrl/admin/settings/security') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/admin/settings/security \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/security

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/security")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/userinfo");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/admin/userinfo" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/userinfo"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/admin/userinfo"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/userinfo");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/userinfo"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

PUT /baseUrl/admin/userinfo HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/userinfo")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/userinfo"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/userinfo")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/admin/userinfo")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/admin/userinfo');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/userinfo',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/userinfo';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/userinfo',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/userinfo")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/userinfo',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/userinfo',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/admin/userinfo');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/userinfo',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/userinfo';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/userinfo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/userinfo" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/userinfo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/admin/userinfo', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/userinfo');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/userinfo');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/userinfo' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/userinfo' -Method PUT -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/admin/userinfo", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/userinfo"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/userinfo"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/userinfo")

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

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.put('/baseUrl/admin/userinfo') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/admin/userinfo \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/userinfo

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/userinfo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/settings/security");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/admin/settings/security" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/settings/security"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/settings/security"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/settings/security");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/admin/settings/security"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

GET /baseUrl/admin/settings/security HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/settings/security")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/settings/security"))
    .header("clearblade-devtoken", "")
    .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}}/admin/settings/security")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/admin/settings/security")
  .header("clearblade-devtoken", "")
  .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}}/admin/settings/security');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/settings/security',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/admin/settings/security';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/settings/security',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/settings/security")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/settings/security',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/settings/security',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/settings/security');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/settings/security',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/admin/settings/security';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/settings/security"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/settings/security" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/admin/settings/security",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/admin/settings/security', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/settings/security');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/admin/settings/security');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/settings/security' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/settings/security' -Method GET -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/settings/security", headers=headers)

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

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

import requests

url = "{{baseUrl}}/admin/settings/security"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/settings/security"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/settings/security")

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

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/admin/settings/security') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/admin/settings/security \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/settings/security

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/settings/security")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v/4/:SystemKey/adapters" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/api/v/4/:SystemKey/adapters HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/v/4/:SystemKey/adapters');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/4/:SystemKey/adapters');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v/4/:SystemKey/adapters', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/api/v/4/:SystemKey/adapters", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/v/4/:SystemKey/adapters') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/api/v/4/:SystemKey/adapters \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

POST /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files' -Method POST -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")

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

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

DELETE /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"))
    .header("clearblade-devtoken", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  method: 'DELETE',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName' -Method DELETE -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("DELETE", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

headers = {"clearblade-devtoken": ""}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

response <- VERB("DELETE", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")

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

request = Net::HTTP::Delete.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName \
  clearblade-devtoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

DELETE /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"))
    .header("clearblade-devtoken", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  method: 'DELETE',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName' -Method DELETE -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("DELETE", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"

headers = {"clearblade-devtoken": ""}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"

response <- VERB("DELETE", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")

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

request = Net::HTTP::Delete.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName \
  clearblade-devtoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

GET /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName' -Method GET -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")

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

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v/4/:SystemKey/adapters" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

GET /baseUrl/api/v/4/:SystemKey/adapters HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters' -Method GET -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/4/:SystemKey/adapters", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters")

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

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/api/v/4/:SystemKey/adapters') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v/4/:SystemKey/adapters \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

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

}

PUT /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {'clearblade-devtoken': ''}
};

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {
    'clearblade-devtoken': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {'clearblade-devtoken': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');

req.headers({
  'clearblade-devtoken': ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName',
  headers: {'clearblade-devtoken': ''}
};

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

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

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

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

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

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

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName' -Method PUT -Headers $headers

import http.client

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

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"

headers = {"clearblade-devtoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")

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

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

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

require 'faraday'

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

response = conn.put('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"

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

	req.Header.Add("clearblade-devtoken", "")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/control HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/control',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/control", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"

headers = {"clearblade-devtoken": ""}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/control') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/control")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

headers = {"clearblade-devtoken": ""}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files/:fileName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v/4/:SystemKey/adapters/:AdapterName/files') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:SystemKey/adapters/:AdapterName/files")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/developers/:systemKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/admin/developers/:systemKey" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/developers/:systemKey"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/admin/developers/:systemKey"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/developers/:systemKey");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/developers/:systemKey"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/admin/developers/:systemKey HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/admin/developers/:systemKey")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/developers/:systemKey"))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/developers/:systemKey")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/admin/developers/:systemKey")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/admin/developers/:systemKey');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/developers/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/developers/:systemKey';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/developers/:systemKey',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/developers/:systemKey")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/developers/:systemKey',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/admin/developers/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/admin/developers/:systemKey');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/developers/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/developers/:systemKey';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/developers/:systemKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/developers/:systemKey" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/developers/:systemKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/admin/developers/:systemKey', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/developers/:systemKey');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/developers/:systemKey');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/developers/:systemKey' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/developers/:systemKey' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/admin/developers/:systemKey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/developers/:systemKey"

headers = {"clearblade-devtoken": ""}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/developers/:systemKey"

response <- VERB("PUT", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/developers/:systemKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/admin/developers/:systemKey') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/developers/:systemKey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/admin/developers/:systemKey \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/developers/:systemKey

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/developers/:systemKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/resetpassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/admin/resetpassword" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/resetpassword"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/admin/resetpassword"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/resetpassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/resetpassword"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/admin/resetpassword HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/admin/resetpassword")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/resetpassword"))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/admin/resetpassword")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/admin/resetpassword")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/admin/resetpassword');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/resetpassword',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/resetpassword';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/resetpassword',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/resetpassword")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/resetpassword',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/admin/resetpassword',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/admin/resetpassword');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/resetpassword',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/resetpassword';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/resetpassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/resetpassword" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/resetpassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/admin/resetpassword', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/resetpassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/resetpassword');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/resetpassword' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/resetpassword' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/admin/resetpassword", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/resetpassword"

headers = {"clearblade-devtoken": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/resetpassword"

response <- VERB("POST", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/resetpassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/admin/resetpassword') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/resetpassword";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/admin/resetpassword \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/resetpassword

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/resetpassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/platform/developer?developer=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/platform/developer" {:headers {:clearblade-devtoken ""}
                                                                    :query-params {:developer ""}})

require "http/client"

url = "{{baseUrl}}/admin/platform/developer?developer="
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/platform/developer?developer="),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/platform/developer?developer=");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/platform/developer?developer="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/platform/developer?developer= HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/platform/developer?developer=")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/platform/developer?developer="))
    .header("clearblade-devtoken", "")
    .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}}/admin/platform/developer?developer=")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/platform/developer?developer=")
  .header("clearblade-devtoken", "")
  .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}}/admin/platform/developer?developer=');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/platform/developer',
  params: {developer: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/platform/developer?developer=';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/platform/developer?developer=',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/platform/developer?developer=")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/platform/developer?developer=',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/platform/developer',
  qs: {developer: ''},
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/platform/developer');

req.query({
  developer: ''
});

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/platform/developer',
  params: {developer: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/platform/developer?developer=';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/platform/developer?developer="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/platform/developer?developer=" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/platform/developer?developer=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/platform/developer?developer=', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/platform/developer');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'developer' => ''
]);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/platform/developer');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'developer' => ''
]));

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/platform/developer?developer=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/platform/developer?developer=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/platform/developer?developer=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/platform/developer"

querystring = {"developer":""}

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/platform/developer"

queryString <- list(developer = "")

response <- VERB("GET", url, query = queryString, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/platform/developer?developer=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/platform/developer') do |req|
  req.headers['clearblade-devtoken'] = ''
  req.params['developer'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/platform/developer";

    let querystring = [
        ("developer", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/admin/platform/developer?developer=' \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - '{{baseUrl}}/admin/platform/developer?developer='

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/platform/developer?developer=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/platform/developers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/platform/developers" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/platform/developers"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/platform/developers"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/platform/developers");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/platform/developers"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/platform/developers HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/platform/developers")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/platform/developers"))
    .header("clearblade-devtoken", "")
    .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}}/admin/platform/developers")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/platform/developers")
  .header("clearblade-devtoken", "")
  .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}}/admin/platform/developers');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/platform/developers',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/platform/developers';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/platform/developers',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/platform/developers")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/platform/developers',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/platform/developers',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/platform/developers');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/platform/developers',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/platform/developers';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/platform/developers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/platform/developers" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/platform/developers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/platform/developers', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/platform/developers');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/platform/developers');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/platform/developers' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/platform/developers' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/platform/developers", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/platform/developers"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/platform/developers"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/platform/developers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/platform/developers') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/platform/developers";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/platform/developers \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/platform/developers

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/platform/developers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/count/developers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/count/developers" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/count/developers"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/count/developers"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/count/developers");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/count/developers"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/count/developers HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/count/developers")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/count/developers"))
    .header("clearblade-devtoken", "")
    .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}}/admin/count/developers")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/count/developers")
  .header("clearblade-devtoken", "")
  .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}}/admin/count/developers');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/count/developers',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/count/developers';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/count/developers',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/count/developers")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/count/developers',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/count/developers',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/count/developers');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/count/developers',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/count/developers';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/count/developers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/count/developers" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/count/developers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/count/developers', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/count/developers');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/count/developers');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/count/developers' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/count/developers' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/count/developers", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/count/developers"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/count/developers"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/count/developers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/count/developers') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/count/developers";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/count/developers \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/count/developers

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/count/developers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/count/systems");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/count/systems" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/count/systems"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/count/systems"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/count/systems");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/count/systems"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/count/systems HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/count/systems")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/count/systems"))
    .header("clearblade-devtoken", "")
    .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}}/admin/count/systems")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/count/systems")
  .header("clearblade-devtoken", "")
  .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}}/admin/count/systems');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/count/systems',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/count/systems';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/count/systems',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/count/systems")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/count/systems',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/count/systems',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/count/systems');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/count/systems',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/count/systems';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/count/systems"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/count/systems" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/count/systems",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/count/systems', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/count/systems');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/count/systems');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/count/systems' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/count/systems' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/count/systems", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/count/systems"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/count/systems"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/count/systems")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/count/systems') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/count/systems";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/count/systems \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/count/systems

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/count/systems")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/pkey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/pkey" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/pkey"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/pkey"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/pkey");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/pkey"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/pkey HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/pkey")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/pkey"))
    .header("clearblade-devtoken", "")
    .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}}/admin/pkey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/pkey")
  .header("clearblade-devtoken", "")
  .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}}/admin/pkey');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/pkey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/pkey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/pkey',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/pkey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/pkey',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/pkey',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/pkey');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/pkey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/pkey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/pkey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/pkey" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/pkey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/pkey', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/pkey');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/pkey');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/pkey' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/pkey' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/pkey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/pkey"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/pkey"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/pkey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/pkey') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/pkey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/pkey \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/pkey

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/pkey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/platform/:systemKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/platform/:systemKey" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/platform/:systemKey"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/platform/:systemKey"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/platform/:systemKey");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/platform/:systemKey"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/platform/:systemKey HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/platform/:systemKey")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/platform/:systemKey"))
    .header("clearblade-devtoken", "")
    .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}}/admin/platform/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/platform/:systemKey")
  .header("clearblade-devtoken", "")
  .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}}/admin/platform/:systemKey');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/platform/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/platform/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/platform/:systemKey',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/platform/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/platform/:systemKey',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/platform/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/platform/:systemKey');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/platform/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/platform/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/platform/:systemKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/platform/:systemKey" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/platform/:systemKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/platform/:systemKey', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/platform/:systemKey');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/platform/:systemKey');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/platform/:systemKey' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/platform/:systemKey' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/platform/:systemKey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/platform/:systemKey"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/platform/:systemKey"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/platform/:systemKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/platform/:systemKey') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/platform/:systemKey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/platform/:systemKey \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/platform/:systemKey

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/platform/:systemKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/systems/:devEmail");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/systems/:devEmail" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/systems/:devEmail"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/systems/:devEmail"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/systems/:devEmail");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/systems/:devEmail"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/systems/:devEmail HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/systems/:devEmail")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/systems/:devEmail"))
    .header("clearblade-devtoken", "")
    .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}}/admin/systems/:devEmail")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/systems/:devEmail")
  .header("clearblade-devtoken", "")
  .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}}/admin/systems/:devEmail');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/systems/:devEmail',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/systems/:devEmail';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/systems/:devEmail',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/systems/:devEmail")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/systems/:devEmail',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/systems/:devEmail',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/systems/:devEmail');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/systems/:devEmail',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/systems/:devEmail';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/systems/:devEmail"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/systems/:devEmail" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/systems/:devEmail",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/systems/:devEmail', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/systems/:devEmail');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/systems/:devEmail');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/systems/:devEmail' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/systems/:devEmail' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/systems/:devEmail", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/systems/:devEmail"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/systems/:devEmail"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/systems/:devEmail")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/systems/:devEmail') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/systems/:devEmail";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/systems/:devEmail \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/systems/:devEmail

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/systems/:devEmail")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/audit/:systemKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/audit/:systemKey" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/audit/:systemKey"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/audit/:systemKey"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/audit/:systemKey");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/audit/:systemKey"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/audit/:systemKey HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/audit/:systemKey")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/audit/:systemKey"))
    .header("clearblade-devtoken", "")
    .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}}/admin/audit/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/audit/:systemKey")
  .header("clearblade-devtoken", "")
  .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}}/admin/audit/:systemKey');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/audit/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/audit/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/audit/:systemKey',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/audit/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/audit/:systemKey',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/audit/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/audit/:systemKey');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/audit/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/audit/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/audit/:systemKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/audit/:systemKey" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/audit/:systemKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/audit/:systemKey', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/audit/:systemKey');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/audit/:systemKey');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/audit/:systemKey' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/audit/:systemKey' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/audit/:systemKey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/audit/:systemKey"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/audit/:systemKey"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/audit/:systemKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/audit/:systemKey') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/audit/:systemKey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/audit/:systemKey \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/audit/:systemKey

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/audit/:systemKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/audit");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/audit" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/audit"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/audit"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/audit");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/audit"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/audit HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/audit")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/audit"))
    .header("clearblade-devtoken", "")
    .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}}/admin/audit")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/audit")
  .header("clearblade-devtoken", "")
  .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}}/admin/audit');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/audit',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/audit';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/audit',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/audit")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/audit',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/audit',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/audit');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/audit',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/audit';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/audit"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/audit" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/audit",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/audit', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/audit');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/audit');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/audit' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/audit' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/audit", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/audit"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/audit"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/audit")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/audit') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/audit";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/audit \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/audit

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/audit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/audit/:systemKey/count");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/audit/:systemKey/count" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/audit/:systemKey/count"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/audit/:systemKey/count"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/audit/:systemKey/count");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/audit/:systemKey/count"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/audit/:systemKey/count HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/audit/:systemKey/count")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/audit/:systemKey/count"))
    .header("clearblade-devtoken", "")
    .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}}/admin/audit/:systemKey/count")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/audit/:systemKey/count")
  .header("clearblade-devtoken", "")
  .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}}/admin/audit/:systemKey/count');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/audit/:systemKey/count',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/audit/:systemKey/count';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/audit/:systemKey/count',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/audit/:systemKey/count")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/audit/:systemKey/count',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/audit/:systemKey/count',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/audit/:systemKey/count');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/audit/:systemKey/count',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/audit/:systemKey/count';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/audit/:systemKey/count"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/audit/:systemKey/count" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/audit/:systemKey/count",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/audit/:systemKey/count', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/audit/:systemKey/count');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/audit/:systemKey/count');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/audit/:systemKey/count' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/audit/:systemKey/count' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/audit/:systemKey/count", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/audit/:systemKey/count"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/audit/:systemKey/count"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/audit/:systemKey/count")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/audit/:systemKey/count') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/audit/:systemKey/count";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/audit/:systemKey/count \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/audit/:systemKey/count

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/audit/:systemKey/count")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/platform/systems/:systemKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/platform/systems/:systemKey" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/platform/systems/:systemKey"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/platform/systems/:systemKey"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/platform/systems/:systemKey");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/platform/systems/:systemKey"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/platform/systems/:systemKey HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/platform/systems/:systemKey")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/platform/systems/:systemKey"))
    .header("clearblade-devtoken", "")
    .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}}/admin/platform/systems/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/platform/systems/:systemKey")
  .header("clearblade-devtoken", "")
  .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}}/admin/platform/systems/:systemKey');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/platform/systems/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/platform/systems/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/platform/systems/:systemKey',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/platform/systems/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/platform/systems/:systemKey',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/platform/systems/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/platform/systems/:systemKey');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/platform/systems/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/platform/systems/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/platform/systems/:systemKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/platform/systems/:systemKey" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/platform/systems/:systemKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/platform/systems/:systemKey', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/platform/systems/:systemKey');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/platform/systems/:systemKey');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/platform/systems/:systemKey' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/platform/systems/:systemKey' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/platform/systems/:systemKey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/platform/systems/:systemKey"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/platform/systems/:systemKey"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/platform/systems/:systemKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/platform/systems/:systemKey') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/platform/systems/:systemKey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/platform/systems/:systemKey \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/platform/systems/:systemKey

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/platform/systems/:systemKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/platform/systems");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/platform/systems" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/platform/systems"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/platform/systems"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/platform/systems");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/platform/systems"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/platform/systems HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/platform/systems")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/platform/systems"))
    .header("clearblade-devtoken", "")
    .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}}/admin/platform/systems")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/platform/systems")
  .header("clearblade-devtoken", "")
  .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}}/admin/platform/systems');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/platform/systems',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/platform/systems';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/platform/systems',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/platform/systems")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/platform/systems',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/platform/systems',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/platform/systems');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/platform/systems',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/platform/systems';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/platform/systems"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/platform/systems" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/platform/systems",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/platform/systems', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/platform/systems');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/platform/systems');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/platform/systems' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/platform/systems' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/platform/systems", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/platform/systems"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/platform/systems"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/platform/systems")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/platform/systems') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/platform/systems";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/platform/systems \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/platform/systems

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/platform/systems")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/admin/audit/count");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/admin/audit/count" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/admin/audit/count"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/admin/audit/count"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/admin/audit/count");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/admin/audit/count"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/admin/audit/count HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/admin/audit/count")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/admin/audit/count"))
    .header("clearblade-devtoken", "")
    .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}}/admin/audit/count")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/admin/audit/count")
  .header("clearblade-devtoken", "")
  .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}}/admin/audit/count');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/admin/audit/count',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/admin/audit/count';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/admin/audit/count',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/admin/audit/count")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/admin/audit/count',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  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}}/admin/audit/count',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/admin/audit/count');

req.headers({
  'clearblade-devtoken': ''
});

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}}/admin/audit/count',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/admin/audit/count';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/admin/audit/count"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/admin/audit/count" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/admin/audit/count",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/admin/audit/count', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/admin/audit/count');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/admin/audit/count');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/admin/audit/count' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/admin/audit/count' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/admin/audit/count", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/admin/audit/count"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/admin/audit/count"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/admin/audit/count")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/admin/audit/count') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/admin/audit/count";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/admin/audit/count \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/admin/audit/count

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/admin/audit/count")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-usertoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName" {:headers {:clearblade-usertoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"
headers = HTTP::Headers{
  "clearblade-usertoken" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"),
    Headers =
    {
        { "clearblade-usertoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-usertoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("clearblade-usertoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v/1/code/:systemKey/:serviceName HTTP/1.1
Clearblade-Usertoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .setHeader("clearblade-usertoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"))
    .header("clearblade-usertoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .post(null)
  .addHeader("clearblade-usertoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .header("clearblade-usertoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');
xhr.setRequestHeader('clearblade-usertoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  headers: {'clearblade-usertoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName';
const options = {method: 'POST', headers: {'clearblade-usertoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  method: 'POST',
  headers: {
    'clearblade-usertoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .post(null)
  .addHeader("clearblade-usertoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/1/code/:systemKey/:serviceName',
  headers: {
    'clearblade-usertoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  headers: {'clearblade-usertoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');

req.headers({
  'clearblade-usertoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  headers: {'clearblade-usertoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName';
const options = {method: 'POST', headers: {'clearblade-usertoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-usertoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName" in
let headers = Header.add (Header.init ()) "clearblade-usertoken" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-usertoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName', [
  'headers' => [
    'clearblade-usertoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-usertoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-usertoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-usertoken': "" }

conn.request("POST", "/baseUrl/api/v/1/code/:systemKey/:serviceName", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"

headers = {"clearblade-usertoken": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"

response <- VERB("POST", url, add_headers('clearblade-usertoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["clearblade-usertoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v/1/code/:systemKey/:serviceName') do |req|
  req.headers['clearblade-usertoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-usertoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/api/v/1/code/:systemKey/:serviceName \
  clearblade-usertoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-usertoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/1/code/:systemKey/:serviceName

import Foundation

let headers = ["clearblade-usertoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/:systemKey/code/failed");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v/4/:systemKey/code/failed" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/:systemKey/code/failed"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/:systemKey/code/failed"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/:systemKey/code/failed");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/:systemKey/code/failed"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v/4/:systemKey/code/failed HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/4/:systemKey/code/failed")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/:systemKey/code/failed"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/:systemKey/code/failed")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/4/:systemKey/code/failed")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v/4/:systemKey/code/failed');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:systemKey/code/failed',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/:systemKey/code/failed';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/:systemKey/code/failed',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/:systemKey/code/failed")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/:systemKey/code/failed',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:systemKey/code/failed',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/4/:systemKey/code/failed');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/:systemKey/code/failed',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/:systemKey/code/failed';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/:systemKey/code/failed"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/:systemKey/code/failed" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/:systemKey/code/failed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v/4/:systemKey/code/failed', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/:systemKey/code/failed');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/:systemKey/code/failed');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/:systemKey/code/failed' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/:systemKey/code/failed' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/4/:systemKey/code/failed", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/:systemKey/code/failed"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/:systemKey/code/failed"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/:systemKey/code/failed")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v/4/:systemKey/code/failed') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/:systemKey/code/failed";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v/4/:systemKey/code/failed \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/:systemKey/code/failed

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/:systemKey/code/failed")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v/1/code/:systemKey/:serviceName HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/1/code/:systemKey/:serviceName',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/1/code/:systemKey/:serviceName');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/1/code/:systemKey/:serviceName' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/1/code/:systemKey/:serviceName", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v/1/code/:systemKey/:serviceName') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v/1/code/:systemKey/:serviceName \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/1/code/:systemKey/:serviceName

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/1/code/:systemKey/:serviceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/3/code/codemeta/:systemKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v/3/code/codemeta/:systemKey" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/3/code/codemeta/:systemKey"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/3/code/codemeta/:systemKey"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/3/code/codemeta/:systemKey");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/3/code/codemeta/:systemKey"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v/3/code/codemeta/:systemKey HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/3/code/codemeta/:systemKey")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/3/code/codemeta/:systemKey"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/3/code/codemeta/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/3/code/codemeta/:systemKey")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v/3/code/codemeta/:systemKey');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/3/code/codemeta/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/3/code/codemeta/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/3/code/codemeta/:systemKey',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/3/code/codemeta/:systemKey")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/3/code/codemeta/:systemKey',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/3/code/codemeta/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/3/code/codemeta/:systemKey');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/3/code/codemeta/:systemKey',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/3/code/codemeta/:systemKey';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/3/code/codemeta/:systemKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/3/code/codemeta/:systemKey" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/3/code/codemeta/:systemKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v/3/code/codemeta/:systemKey', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/3/code/codemeta/:systemKey');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/3/code/codemeta/:systemKey');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/3/code/codemeta/:systemKey' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/3/code/codemeta/:systemKey' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/3/code/codemeta/:systemKey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/3/code/codemeta/:systemKey"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/3/code/codemeta/:systemKey"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/3/code/codemeta/:systemKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v/3/code/codemeta/:systemKey') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/3/code/codemeta/:systemKey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v/3/code/codemeta/:systemKey \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/3/code/codemeta/:systemKey

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/3/code/codemeta/:systemKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex" {:headers {:clearblade-devtoken ""}
                                                                                                :query-params {:columnName ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName= HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex',
  qs: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex');

req.query({
  columnName: ''
});

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'columnName' => ''
]);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'columnName' => ''
]));

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex"

querystring = {"columnName":""}

headers = {"clearblade-devtoken": ""}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex"

queryString <- list(columnName = "")

response <- VERB("POST", url, query = queryString, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex') do |req|
  req.headers['clearblade-devtoken'] = ''
  req.params['columnName'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex";

    let querystring = [
        ("columnName", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=' \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName='

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index" {:headers {:clearblade-devtoken ""}
                                                                                          :query-params {:columnName ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v/4/data/:systemKey/:collectionName/index?columnName= HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="))
    .header("clearblade-devtoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=',
  method: 'POST',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .post(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/data/:systemKey/:collectionName/index?columnName=',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index',
  qs: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index');

req.query({
  columnName: ''
});

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=';
const options = {method: 'POST', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'columnName' => ''
]);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'columnName' => ''
]));

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("POST", "/baseUrl/api/v/4/data/:systemKey/:collectionName/index?columnName=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index"

querystring = {"columnName":""}

headers = {"clearblade-devtoken": ""}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index"

queryString <- list(columnName = "")

response <- VERB("POST", url, query = queryString, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v/4/data/:systemKey/:collectionName/index') do |req|
  req.headers['clearblade-devtoken'] = ''
  req.params['columnName'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index";

    let querystring = [
        ("columnName", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=' \
  clearblade-devtoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName='

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/3/collectionmanagement");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-usertoken: ");
headers = curl_slist_append(headers, "clearblade-systemkey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v/3/collectionmanagement" {:headers {:clearblade-usertoken ""
                                                                                   :clearblade-systemkey ""}})

require "http/client"

url = "{{baseUrl}}/api/v/3/collectionmanagement"
headers = HTTP::Headers{
  "clearblade-usertoken" => ""
  "clearblade-systemkey" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/3/collectionmanagement"),
    Headers =
    {
        { "clearblade-usertoken", "" },
        { "clearblade-systemkey", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/3/collectionmanagement");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-usertoken", "");
request.AddHeader("clearblade-systemkey", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/3/collectionmanagement"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("clearblade-usertoken", "")
	req.Header.Add("clearblade-systemkey", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v/3/collectionmanagement HTTP/1.1
Clearblade-Usertoken: 
Clearblade-Systemkey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/3/collectionmanagement")
  .setHeader("clearblade-usertoken", "")
  .setHeader("clearblade-systemkey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/3/collectionmanagement"))
    .header("clearblade-usertoken", "")
    .header("clearblade-systemkey", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/3/collectionmanagement")
  .post(null)
  .addHeader("clearblade-usertoken", "")
  .addHeader("clearblade-systemkey", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/3/collectionmanagement")
  .header("clearblade-usertoken", "")
  .header("clearblade-systemkey", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v/3/collectionmanagement');
xhr.setRequestHeader('clearblade-usertoken', '');
xhr.setRequestHeader('clearblade-systemkey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/3/collectionmanagement';
const options = {
  method: 'POST',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  method: 'POST',
  headers: {
    'clearblade-usertoken': '',
    'clearblade-systemkey': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/3/collectionmanagement")
  .post(null)
  .addHeader("clearblade-usertoken", "")
  .addHeader("clearblade-systemkey", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/3/collectionmanagement',
  headers: {
    'clearblade-usertoken': '',
    'clearblade-systemkey': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/3/collectionmanagement');

req.headers({
  'clearblade-usertoken': '',
  'clearblade-systemkey': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/3/collectionmanagement';
const options = {
  method: 'POST',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-usertoken": @"",
                           @"clearblade-systemkey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/3/collectionmanagement"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/3/collectionmanagement" in
let headers = Header.add_list (Header.init ()) [
  ("clearblade-usertoken", "");
  ("clearblade-systemkey", "");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/3/collectionmanagement",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "clearblade-systemkey: ",
    "clearblade-usertoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v/3/collectionmanagement', [
  'headers' => [
    'clearblade-systemkey' => '',
    'clearblade-usertoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/3/collectionmanagement');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'clearblade-usertoken' => '',
  'clearblade-systemkey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/3/collectionmanagement');
$request->setRequestMethod('POST');
$request->setHeaders([
  'clearblade-usertoken' => '',
  'clearblade-systemkey' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$headers.Add("clearblade-systemkey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/3/collectionmanagement' -Method POST -Headers $headers

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$headers.Add("clearblade-systemkey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/3/collectionmanagement' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'clearblade-usertoken': "",
    'clearblade-systemkey': ""
}

conn.request("POST", "/baseUrl/api/v/3/collectionmanagement", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/3/collectionmanagement"

headers = {
    "clearblade-usertoken": "",
    "clearblade-systemkey": ""
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/3/collectionmanagement"

response <- VERB("POST", url, add_headers('clearblade-usertoken' = '', 'clearblade-systemkey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/3/collectionmanagement")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["clearblade-usertoken"] = ''
request["clearblade-systemkey"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v/3/collectionmanagement') do |req|
  req.headers['clearblade-usertoken'] = ''
  req.headers['clearblade-systemkey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/3/collectionmanagement";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-usertoken", "".parse().unwrap());
    headers.insert("clearblade-systemkey", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/api/v/3/collectionmanagement \
  clearblade-systemkey:'' \
  clearblade-usertoken:''

wget --quiet \
  --method POST \
  --header 'clearblade-usertoken: ' \
  --header 'clearblade-systemkey: ' \
  --output-document \
  - {{baseUrl}}/api/v/3/collectionmanagement

import Foundation

let headers = [
  "clearblade-usertoken": "",
  "clearblade-systemkey": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/3/collectionmanagement")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index" {:headers {:clearblade-devtoken ""}
                                                                                            :query-params {:columnName ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/v/4/data/:systemKey/:collectionName/index?columnName= HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="))
    .header("clearblade-devtoken", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=',
  method: 'DELETE',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/data/:systemKey/:collectionName/index?columnName=',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index',
  qs: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index');

req.query({
  columnName: ''
});

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'columnName' => ''
]);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'columnName' => ''
]));

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("DELETE", "/baseUrl/api/v/4/data/:systemKey/:collectionName/index?columnName=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index"

querystring = {"columnName":""}

headers = {"clearblade-devtoken": ""}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index"

queryString <- list(columnName = "")

response <- VERB("DELETE", url, query = queryString, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/v/4/data/:systemKey/:collectionName/index') do |req|
  req.headers['clearblade-devtoken'] = ''
  req.params['columnName'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index";

    let querystring = [
        ("columnName", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=' \
  clearblade-devtoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName='

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/index?columnName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/3/collectionmanagement?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-usertoken: ");
headers = curl_slist_append(headers, "clearblade-systemkey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v/3/collectionmanagement" {:headers {:clearblade-usertoken ""
                                                                                     :clearblade-systemkey ""}
                                                                           :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/api/v/3/collectionmanagement?id="
headers = HTTP::Headers{
  "clearblade-usertoken" => ""
  "clearblade-systemkey" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/v/3/collectionmanagement?id="),
    Headers =
    {
        { "clearblade-usertoken", "" },
        { "clearblade-systemkey", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/3/collectionmanagement?id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-usertoken", "");
request.AddHeader("clearblade-systemkey", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/3/collectionmanagement?id="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("clearblade-usertoken", "")
	req.Header.Add("clearblade-systemkey", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/v/3/collectionmanagement?id= HTTP/1.1
Clearblade-Usertoken: 
Clearblade-Systemkey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v/3/collectionmanagement?id=")
  .setHeader("clearblade-usertoken", "")
  .setHeader("clearblade-systemkey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/3/collectionmanagement?id="))
    .header("clearblade-usertoken", "")
    .header("clearblade-systemkey", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/3/collectionmanagement?id=")
  .delete(null)
  .addHeader("clearblade-usertoken", "")
  .addHeader("clearblade-systemkey", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v/3/collectionmanagement?id=")
  .header("clearblade-usertoken", "")
  .header("clearblade-systemkey", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/v/3/collectionmanagement?id=');
xhr.setRequestHeader('clearblade-usertoken', '');
xhr.setRequestHeader('clearblade-systemkey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  params: {id: ''},
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/3/collectionmanagement?id=';
const options = {
  method: 'DELETE',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/3/collectionmanagement?id=',
  method: 'DELETE',
  headers: {
    'clearblade-usertoken': '',
    'clearblade-systemkey': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/3/collectionmanagement?id=")
  .delete(null)
  .addHeader("clearblade-usertoken", "")
  .addHeader("clearblade-systemkey", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/3/collectionmanagement?id=',
  headers: {
    'clearblade-usertoken': '',
    'clearblade-systemkey': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  qs: {id: ''},
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v/3/collectionmanagement');

req.query({
  id: ''
});

req.headers({
  'clearblade-usertoken': '',
  'clearblade-systemkey': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  params: {id: ''},
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/3/collectionmanagement?id=';
const options = {
  method: 'DELETE',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-usertoken": @"",
                           @"clearblade-systemkey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/3/collectionmanagement?id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/3/collectionmanagement?id=" in
let headers = Header.add_list (Header.init ()) [
  ("clearblade-usertoken", "");
  ("clearblade-systemkey", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/3/collectionmanagement?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-systemkey: ",
    "clearblade-usertoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/v/3/collectionmanagement?id=', [
  'headers' => [
    'clearblade-systemkey' => '',
    'clearblade-usertoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/3/collectionmanagement');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'id' => ''
]);

$request->setHeaders([
  'clearblade-usertoken' => '',
  'clearblade-systemkey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/3/collectionmanagement');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'clearblade-usertoken' => '',
  'clearblade-systemkey' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$headers.Add("clearblade-systemkey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/3/collectionmanagement?id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$headers.Add("clearblade-systemkey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/3/collectionmanagement?id=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'clearblade-usertoken': "",
    'clearblade-systemkey': ""
}

conn.request("DELETE", "/baseUrl/api/v/3/collectionmanagement?id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/3/collectionmanagement"

querystring = {"id":""}

headers = {
    "clearblade-usertoken": "",
    "clearblade-systemkey": ""
}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/3/collectionmanagement"

queryString <- list(id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('clearblade-usertoken' = '', 'clearblade-systemkey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/3/collectionmanagement?id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["clearblade-usertoken"] = ''
request["clearblade-systemkey"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/v/3/collectionmanagement') do |req|
  req.headers['clearblade-usertoken'] = ''
  req.headers['clearblade-systemkey'] = ''
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/3/collectionmanagement";

    let querystring = [
        ("id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-usertoken", "".parse().unwrap());
    headers.insert("clearblade-systemkey", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/api/v/3/collectionmanagement?id=' \
  clearblade-systemkey:'' \
  clearblade-usertoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-usertoken: ' \
  --header 'clearblade-systemkey: ' \
  --output-document \
  - '{{baseUrl}}/api/v/3/collectionmanagement?id='

import Foundation

let headers = [
  "clearblade-usertoken": "",
  "clearblade-systemkey": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/3/collectionmanagement?id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex" {:headers {:clearblade-devtoken ""}
                                                                                                  :query-params {:columnName ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName= HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="))
    .header("clearblade-devtoken", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=',
  method: 'DELETE',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")
  .delete(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex',
  qs: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex');

req.query({
  columnName: ''
});

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex',
  params: {columnName: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=';
const options = {method: 'DELETE', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'columnName' => ''
]);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'columnName' => ''
]));

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("DELETE", "/baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex"

querystring = {"columnName":""}

headers = {"clearblade-devtoken": ""}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex"

queryString <- list(columnName = "")

response <- VERB("DELETE", url, query = queryString, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/v/4/data/:systemKey/:collectionName/uniqueindex') do |req|
  req.headers['clearblade-devtoken'] = ''
  req.params['columnName'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex";

    let querystring = [
        ("columnName", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=' \
  clearblade-devtoken:''

wget --quiet \
  --method DELETE \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName='

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/uniqueindex?columnName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/3/allcollections/:systemKey");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-usertoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v/3/allcollections/:systemKey" {:headers {:clearblade-usertoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/3/allcollections/:systemKey"
headers = HTTP::Headers{
  "clearblade-usertoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/3/allcollections/:systemKey"),
    Headers =
    {
        { "clearblade-usertoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/3/allcollections/:systemKey");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-usertoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/3/allcollections/:systemKey"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-usertoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v/3/allcollections/:systemKey HTTP/1.1
Clearblade-Usertoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/3/allcollections/:systemKey")
  .setHeader("clearblade-usertoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/3/allcollections/:systemKey"))
    .header("clearblade-usertoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/3/allcollections/:systemKey")
  .get()
  .addHeader("clearblade-usertoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/3/allcollections/:systemKey")
  .header("clearblade-usertoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v/3/allcollections/:systemKey');
xhr.setRequestHeader('clearblade-usertoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/3/allcollections/:systemKey',
  headers: {'clearblade-usertoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/3/allcollections/:systemKey';
const options = {method: 'GET', headers: {'clearblade-usertoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/3/allcollections/:systemKey',
  method: 'GET',
  headers: {
    'clearblade-usertoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/3/allcollections/:systemKey")
  .get()
  .addHeader("clearblade-usertoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/3/allcollections/:systemKey',
  headers: {
    'clearblade-usertoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/3/allcollections/:systemKey',
  headers: {'clearblade-usertoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/3/allcollections/:systemKey');

req.headers({
  'clearblade-usertoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/3/allcollections/:systemKey',
  headers: {'clearblade-usertoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/3/allcollections/:systemKey';
const options = {method: 'GET', headers: {'clearblade-usertoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-usertoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/3/allcollections/:systemKey"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/3/allcollections/:systemKey" in
let headers = Header.add (Header.init ()) "clearblade-usertoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/3/allcollections/:systemKey",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-usertoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v/3/allcollections/:systemKey', [
  'headers' => [
    'clearblade-usertoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/3/allcollections/:systemKey');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-usertoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/3/allcollections/:systemKey');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-usertoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/3/allcollections/:systemKey' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/3/allcollections/:systemKey' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-usertoken': "" }

conn.request("GET", "/baseUrl/api/v/3/allcollections/:systemKey", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/3/allcollections/:systemKey"

headers = {"clearblade-usertoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/3/allcollections/:systemKey"

response <- VERB("GET", url, add_headers('clearblade-usertoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/3/allcollections/:systemKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-usertoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v/3/allcollections/:systemKey') do |req|
  req.headers['clearblade-usertoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/3/allcollections/:systemKey";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-usertoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v/3/allcollections/:systemKey \
  clearblade-usertoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-usertoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/3/allcollections/:systemKey

import Foundation

let headers = ["clearblade-usertoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/3/allcollections/:systemKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes" {:headers {:clearblade-devtoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes");
var request = new RestRequest("", Method.Get);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v/4/data/:systemKey/:collectionName/listindexes HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"))
    .header("clearblade-devtoken", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes',
  method: 'GET',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes")
  .get()
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/data/:systemKey/:collectionName/listindexes',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes',
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes');

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes',
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes';
const options = {method: 'GET', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes');
$request->setRequestMethod('GET');
$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes' -Method GET -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("GET", "/baseUrl/api/v/4/data/:systemKey/:collectionName/listindexes", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"

headers = {"clearblade-devtoken": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes"

response <- VERB("GET", url, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v/4/data/:systemKey/:collectionName/listindexes') do |req|
  req.headers['clearblade-devtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes \
  clearblade-devtoken:''

wget --quiet \
  --method GET \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - {{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/listindexes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/3/collectionmanagement");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-usertoken: ");
headers = curl_slist_append(headers, "clearblade-systemkey: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v/3/collectionmanagement" {:headers {:clearblade-usertoken ""
                                                                                  :clearblade-systemkey ""}})

require "http/client"

url = "{{baseUrl}}/api/v/3/collectionmanagement"
headers = HTTP::Headers{
  "clearblade-usertoken" => ""
  "clearblade-systemkey" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v/3/collectionmanagement"),
    Headers =
    {
        { "clearblade-usertoken", "" },
        { "clearblade-systemkey", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/3/collectionmanagement");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-usertoken", "");
request.AddHeader("clearblade-systemkey", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/3/collectionmanagement"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("clearblade-usertoken", "")
	req.Header.Add("clearblade-systemkey", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/v/3/collectionmanagement HTTP/1.1
Clearblade-Usertoken: 
Clearblade-Systemkey: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v/3/collectionmanagement")
  .setHeader("clearblade-usertoken", "")
  .setHeader("clearblade-systemkey", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/3/collectionmanagement"))
    .header("clearblade-usertoken", "")
    .header("clearblade-systemkey", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/3/collectionmanagement")
  .put(null)
  .addHeader("clearblade-usertoken", "")
  .addHeader("clearblade-systemkey", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/v/3/collectionmanagement")
  .header("clearblade-usertoken", "")
  .header("clearblade-systemkey", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/v/3/collectionmanagement');
xhr.setRequestHeader('clearblade-usertoken', '');
xhr.setRequestHeader('clearblade-systemkey', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/3/collectionmanagement';
const options = {
  method: 'PUT',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  method: 'PUT',
  headers: {
    'clearblade-usertoken': '',
    'clearblade-systemkey': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/3/collectionmanagement")
  .put(null)
  .addHeader("clearblade-usertoken", "")
  .addHeader("clearblade-systemkey", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/3/collectionmanagement',
  headers: {
    'clearblade-usertoken': '',
    'clearblade-systemkey': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v/3/collectionmanagement');

req.headers({
  'clearblade-usertoken': '',
  'clearblade-systemkey': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/3/collectionmanagement',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/3/collectionmanagement';
const options = {
  method: 'PUT',
  headers: {'clearblade-usertoken': '', 'clearblade-systemkey': ''}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-usertoken": @"",
                           @"clearblade-systemkey": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/3/collectionmanagement"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/3/collectionmanagement" in
let headers = Header.add_list (Header.init ()) [
  ("clearblade-usertoken", "");
  ("clearblade-systemkey", "");
] in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/3/collectionmanagement",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-systemkey: ",
    "clearblade-usertoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/v/3/collectionmanagement', [
  'headers' => [
    'clearblade-systemkey' => '',
    'clearblade-usertoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/3/collectionmanagement');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'clearblade-usertoken' => '',
  'clearblade-systemkey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/3/collectionmanagement');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'clearblade-usertoken' => '',
  'clearblade-systemkey' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$headers.Add("clearblade-systemkey", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/3/collectionmanagement' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-usertoken", "")
$headers.Add("clearblade-systemkey", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/3/collectionmanagement' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'clearblade-usertoken': "",
    'clearblade-systemkey': ""
}

conn.request("PUT", "/baseUrl/api/v/3/collectionmanagement", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/3/collectionmanagement"

headers = {
    "clearblade-usertoken": "",
    "clearblade-systemkey": ""
}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/3/collectionmanagement"

response <- VERB("PUT", url, add_headers('clearblade-usertoken' = '', 'clearblade-systemkey' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/3/collectionmanagement")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["clearblade-usertoken"] = ''
request["clearblade-systemkey"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/v/3/collectionmanagement') do |req|
  req.headers['clearblade-usertoken'] = ''
  req.headers['clearblade-systemkey'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/3/collectionmanagement";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-usertoken", "".parse().unwrap());
    headers.insert("clearblade-systemkey", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/api/v/3/collectionmanagement \
  clearblade-systemkey:'' \
  clearblade-usertoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-usertoken: ' \
  --header 'clearblade-systemkey: ' \
  --output-document \
  - {{baseUrl}}/api/v/3/collectionmanagement

import Foundation

let headers = [
  "clearblade-usertoken": "",
  "clearblade-systemkey": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/3/collectionmanagement")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-devtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert" {:headers {:clearblade-devtoken ""}
                                                                                          :query-params {:conflictColumn ""}})

require "http/client"

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn="
headers = HTTP::Headers{
  "clearblade-devtoken" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn="),
    Headers =
    {
        { "clearblade-devtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=");
var request = new RestRequest("", Method.Put);
request.AddHeader("clearblade-devtoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn="

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("clearblade-devtoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn= HTTP/1.1
Clearblade-Devtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=")
  .setHeader("clearblade-devtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn="))
    .header("clearblade-devtoken", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=")
  .header("clearblade-devtoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=');
xhr.setRequestHeader('clearblade-devtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert',
  params: {conflictColumn: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=',
  method: 'PUT',
  headers: {
    'clearblade-devtoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=")
  .put(null)
  .addHeader("clearblade-devtoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=',
  headers: {
    'clearblade-devtoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert',
  qs: {conflictColumn: ''},
  headers: {'clearblade-devtoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert');

req.query({
  conflictColumn: ''
});

req.headers({
  'clearblade-devtoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert',
  params: {conflictColumn: ''},
  headers: {'clearblade-devtoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=';
const options = {method: 'PUT', headers: {'clearblade-devtoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"clearblade-devtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=" in
let headers = Header.add (Header.init ()) "clearblade-devtoken" "" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "clearblade-devtoken: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=', [
  'headers' => [
    'clearblade-devtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'conflictColumn' => ''
]);

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'conflictColumn' => ''
]));

$request->setHeaders([
  'clearblade-devtoken' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("clearblade-devtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'clearblade-devtoken': "" }

conn.request("PUT", "/baseUrl/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert"

querystring = {"conflictColumn":""}

headers = {"clearblade-devtoken": ""}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert"

queryString <- list(conflictColumn = "")

response <- VERB("PUT", url, query = queryString, add_headers('clearblade-devtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["clearblade-devtoken"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/v/4/data/:systemKey/:collectionName/upsert') do |req|
  req.headers['clearblade-devtoken'] = ''
  req.params['conflictColumn'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert";

    let querystring = [
        ("conflictColumn", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("clearblade-devtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=' \
  clearblade-devtoken:''

wget --quiet \
  --method PUT \
  --header 'clearblade-devtoken: ' \
  --output-document \
  - '{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn='

import Foundation

let headers = ["clearblade-devtoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v/4/data/:systemKey/:collectionName/upsert?conflictColumn=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v/1/data/:collectionID");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "clearblade-usertoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v/1/data/:collectionID" {:headers {:clearblade-usertoken ""}})

require "http/client"

url = "{{baseUrl}}/api/v/1/data/:collectionID"
headers = HTTP::Headers{
  "clearblade-usertoken" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v/1/data/:collectionID"),
    Headers =
    {
        { "clearblade-usertoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v/1/data/:collectionID");
var request = new RestRequest("", Method.Post);
request.AddHeader("clearblade-usertoken", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v/1/data/:collectionID"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("clearblade-usertoken", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v/1/data/:collectionID HTTP/1.1
Clearblade-Usertoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v/1/data/:collectionID")
  .setHeader("clearblade-usertoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v/1/data/:collectionID"))
    .header("clearblade-usertoken", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v/1/data/:collectionID")
  .post(null)
  .addHeader("clearblade-usertoken", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v/1/data/:collectionID")
  .header("clearblade-usertoken", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v/1/data/:collectionID');
xhr.setRequestHeader('clearblade-usertoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/1/data/:collectionID',
  headers: {'clearblade-usertoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v/1/data/:collectionID';
const options = {method: 'POST', headers: {'clearblade-usertoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v/1/data/:collectionID',
  method: 'POST',
  headers: {
    'clearblade-usertoken': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v/1/data/:collectionID")
  .post(null)
  .addHeader("clearblade-usertoken", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v/1/data/:collectionID',
  headers: {
    'clearblade-usertoken': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/1/data/:collectionID',
  headers: {'clearblade-usertoken': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v/1/data/:collectionID');

req.headers({
  'clearblade-usertoken': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v/1/data/:collectionID',
  headers: {'clearblade-usertoken': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v/1/data/:collectionID';
const options = {method: 'POST', headers: {'clearblade-usertoken': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}