POST Create an Attribute
{{baseUrl}}/attributes/computed
BODY json
{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/attributes/computed");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/attributes/computed" {:content-type :json
                                                                :form-params {:attribute ""
                                                                              :description ""
                                                                              :expression ""
                                                                              :id 0
                                                                              :type ""}})
require "http/client"

url = "{{baseUrl}}/attributes/computed"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/attributes/computed"),
    Content = new StringContent("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/attributes/computed");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/attributes/computed"

	payload := strings.NewReader("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")

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

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

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

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

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

}
POST /baseUrl/attributes/computed HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attributes/computed"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/attributes/computed")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/attributes/computed")
  .header("content-type", "application/json")
  .body("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attribute: '',
  description: '',
  expression: '',
  id: 0,
  type: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/attributes/computed',
  headers: {'content-type': 'application/json'},
  data: {attribute: '', description: '', expression: '', id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/attributes/computed';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attribute":"","description":"","expression":"","id":0,"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/attributes/computed',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attribute": "",\n  "description": "",\n  "expression": "",\n  "id": 0,\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/attributes/computed")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attribute: '', description: '', expression: '', id: 0, type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/attributes/computed',
  headers: {'content-type': 'application/json'},
  body: {attribute: '', description: '', expression: '', id: 0, type: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/attributes/computed');

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

req.type('json');
req.send({
  attribute: '',
  description: '',
  expression: '',
  id: 0,
  type: ''
});

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}}/attributes/computed',
  headers: {'content-type': 'application/json'},
  data: {attribute: '', description: '', expression: '', id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/attributes/computed';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attribute":"","description":"","expression":"","id":0,"type":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attribute": @"",
                              @"description": @"",
                              @"expression": @"",
                              @"id": @0,
                              @"type": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/attributes/computed" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/attributes/computed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attribute' => '',
    'description' => '',
    'expression' => '',
    'id' => 0,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/attributes/computed', [
  'body' => '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/attributes/computed');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attribute' => '',
  'description' => '',
  'expression' => '',
  'id' => 0,
  'type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attribute' => '',
  'description' => '',
  'expression' => '',
  'id' => 0,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/attributes/computed');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attributes/computed' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attributes/computed' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}'
import http.client

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

payload = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

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

conn.request("POST", "/baseUrl/attributes/computed", payload, headers)

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

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

url = "{{baseUrl}}/attributes/computed"

payload = {
    "attribute": "",
    "description": "",
    "expression": "",
    "id": 0,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/attributes/computed"

payload <- "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attributes/computed")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/attributes/computed') do |req|
  req.body = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attribute": "",
        "description": "",
        "expression": "",
        "id": 0,
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/attributes/computed \
  --header 'content-type: application/json' \
  --data '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}'
echo '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}' |  \
  http POST {{baseUrl}}/attributes/computed \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attribute": "",\n  "description": "",\n  "expression": "",\n  "id": 0,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/attributes/computed
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()
DELETE Delete an Attribute
{{baseUrl}}/attributes/computed/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/attributes/computed/:id")
require "http/client"

url = "{{baseUrl}}/attributes/computed/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/attributes/computed/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/attributes/computed/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/attributes/computed/:id"

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

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

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

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

}
DELETE /baseUrl/attributes/computed/:id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attributes/computed/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/attributes/computed/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/attributes/computed/:id")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/attributes/computed/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/attributes/computed/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/attributes/computed/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/attributes/computed/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/attributes/computed/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/attributes/computed/:id',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/attributes/computed/:id'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/attributes/computed/:id');

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/attributes/computed/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/attributes/computed/:id';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/attributes/computed/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

let uri = Uri.of_string "{{baseUrl}}/attributes/computed/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/attributes/computed/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/attributes/computed/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/attributes/computed/:id');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/attributes/computed/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attributes/computed/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attributes/computed/:id' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/attributes/computed/:id")

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

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

url = "{{baseUrl}}/attributes/computed/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/attributes/computed/:id"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attributes/computed/:id")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/attributes/computed/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/attributes/computed/:id
http DELETE {{baseUrl}}/attributes/computed/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/attributes/computed/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/attributes/computed/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()
GET Fetch a list of Attributes
{{baseUrl}}/attributes/computed
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/attributes/computed");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/attributes/computed")
require "http/client"

url = "{{baseUrl}}/attributes/computed"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/attributes/computed"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/attributes/computed");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/attributes/computed"

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

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

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

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

}
GET /baseUrl/attributes/computed HTTP/1.1
Host: example.com


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/attributes/computed")
  .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}}/attributes/computed');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/attributes/computed'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/attributes/computed';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/attributes/computed',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/attributes/computed',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/attributes/computed'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/attributes/computed');

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}}/attributes/computed'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/attributes/computed';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/attributes/computed"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/attributes/computed" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/attributes/computed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/attributes/computed');

echo $response->getBody();
setUrl('{{baseUrl}}/attributes/computed');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/attributes/computed');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attributes/computed' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attributes/computed' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/attributes/computed")

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

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

url = "{{baseUrl}}/attributes/computed"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/attributes/computed"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attributes/computed")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/attributes/computed') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/attributes/computed
http GET {{baseUrl}}/attributes/computed
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/attributes/computed
import Foundation

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

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

dataTask.resume()
PUT Update an Attribute
{{baseUrl}}/attributes/computed/:id
QUERY PARAMS
id
BODY json
{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/attributes/computed/:id" {:content-type :json
                                                                   :form-params {:attribute ""
                                                                                 :description ""
                                                                                 :expression ""
                                                                                 :id 0
                                                                                 :type ""}})
require "http/client"

url = "{{baseUrl}}/attributes/computed/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/attributes/computed/:id"),
    Content = new StringContent("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/attributes/computed/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/attributes/computed/:id"

	payload := strings.NewReader("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")

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

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

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

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

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

}
PUT /baseUrl/attributes/computed/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/attributes/computed/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attributes/computed/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/attributes/computed/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/attributes/computed/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attribute: '',
  description: '',
  expression: '',
  id: 0,
  type: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/attributes/computed/:id',
  headers: {'content-type': 'application/json'},
  data: {attribute: '', description: '', expression: '', id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/attributes/computed/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attribute":"","description":"","expression":"","id":0,"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/attributes/computed/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attribute": "",\n  "description": "",\n  "expression": "",\n  "id": 0,\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/attributes/computed/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attribute: '', description: '', expression: '', id: 0, type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/attributes/computed/:id',
  headers: {'content-type': 'application/json'},
  body: {attribute: '', description: '', expression: '', id: 0, type: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attribute: '',
  description: '',
  expression: '',
  id: 0,
  type: ''
});

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}}/attributes/computed/:id',
  headers: {'content-type': 'application/json'},
  data: {attribute: '', description: '', expression: '', id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/attributes/computed/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attribute":"","description":"","expression":"","id":0,"type":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attribute": @"",
                              @"description": @"",
                              @"expression": @"",
                              @"id": @0,
                              @"type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/attributes/computed/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

let uri = Uri.of_string "{{baseUrl}}/attributes/computed/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/attributes/computed/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attribute' => '',
    'description' => '',
    'expression' => '',
    'id' => 0,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/attributes/computed/:id', [
  'body' => '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/attributes/computed/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attribute' => '',
  'description' => '',
  'expression' => '',
  'id' => 0,
  'type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attribute' => '',
  'description' => '',
  'expression' => '',
  'id' => 0,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/attributes/computed/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/attributes/computed/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/attributes/computed/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}'
import http.client

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

payload = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/attributes/computed/:id", payload, headers)

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

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

url = "{{baseUrl}}/attributes/computed/:id"

payload = {
    "attribute": "",
    "description": "",
    "expression": "",
    "id": 0,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/attributes/computed/:id"

payload <- "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attributes/computed/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/attributes/computed/:id') do |req|
  req.body = "{\n  \"attribute\": \"\",\n  \"description\": \"\",\n  \"expression\": \"\",\n  \"id\": 0,\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attribute": "",
        "description": "",
        "expression": "",
        "id": 0,
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/attributes/computed/:id \
  --header 'content-type: application/json' \
  --data '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}'
echo '{
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
}' |  \
  http PUT {{baseUrl}}/attributes/computed/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attribute": "",\n  "description": "",\n  "expression": "",\n  "id": 0,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/attributes/computed/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attribute": "",
  "description": "",
  "expression": "",
  "id": 0,
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()
POST Create a Calendar
{{baseUrl}}/calendars
BODY json
{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/calendars" {:content-type :json
                                                      :form-params {:attributes {}
                                                                    :data ""
                                                                    :id 0
                                                                    :name ""}})
require "http/client"

url = "{{baseUrl}}/calendars"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/calendars"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/calendars");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/calendars"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")

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

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

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

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

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

}
POST /baseUrl/calendars HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 61

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calendars"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calendars")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/calendars")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  data: '',
  id: 0,
  name: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calendars',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, data: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/calendars';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"data":"","id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/calendars',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "data": "",\n  "id": 0,\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calendars")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attributes: {}, data: '', id: 0, name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calendars',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, data: '', id: 0, name: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  data: '',
  id: 0,
  name: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/calendars',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, data: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/calendars';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"data":"","id":0,"name":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"data": @"",
                              @"id": @0,
                              @"name": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/calendars" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/calendars",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'data' => '',
    'id' => 0,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/calendars', [
  'body' => '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/calendars');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'data' => '',
  'id' => 0,
  'name' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'data' => '',
  'id' => 0,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calendars');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/calendars' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calendars' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/calendars"

payload = {
    "attributes": {},
    "data": "",
    "id": 0,
    "name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/calendars"

payload <- "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/calendars")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/calendars') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "data": "",
        "id": 0,
        "name": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/calendars \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}'
echo '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}' |  \
  http POST {{baseUrl}}/calendars \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "data": "",\n  "id": 0,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/calendars
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "data": "",
  "id": 0,
  "name": ""
] as [String : Any]

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

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

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

dataTask.resume()
DELETE Delete a Calendar
{{baseUrl}}/calendars/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/calendars/:id")
require "http/client"

url = "{{baseUrl}}/calendars/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/calendars/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/calendars/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/calendars/:id"

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

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

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

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

}
DELETE /baseUrl/calendars/:id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calendars/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/calendars/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/calendars/:id")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/calendars/:id');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/calendars/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/calendars/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/calendars/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/calendars/:id',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/calendars/:id');

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

  console.log(res.body);
});
const axios = require('axios').default;

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/calendars/:id';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calendars/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

let uri = Uri.of_string "{{baseUrl}}/calendars/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/calendars/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/calendars/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/calendars/:id');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/calendars/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/calendars/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calendars/:id' -Method DELETE 
import http.client

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

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

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

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

url = "{{baseUrl}}/calendars/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/calendars/:id"

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

content(response, "text")
require 'uri'
require 'net/http'

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

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/calendars/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/calendars/:id
http DELETE {{baseUrl}}/calendars/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/calendars/:id
import Foundation

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

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

dataTask.resume()
GET Fetch a list of Calendars
{{baseUrl}}/calendars
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/calendars")
require "http/client"

url = "{{baseUrl}}/calendars"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/calendars"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/calendars");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/calendars"

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

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

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

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

}
GET /baseUrl/calendars HTTP/1.1
Host: example.com


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/calendars")
  .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}}/calendars');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/calendars';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/calendars',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/calendars',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/calendars');

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}}/calendars'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/calendars';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/calendars"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/calendars" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/calendars",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/calendars');

echo $response->getBody();
setUrl('{{baseUrl}}/calendars');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/calendars');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/calendars' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calendars' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/calendars")

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

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

url = "{{baseUrl}}/calendars"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/calendars"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/calendars")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/calendars') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/calendars
http GET {{baseUrl}}/calendars
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/calendars
import Foundation

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

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

dataTask.resume()
PUT Update a Calendar
{{baseUrl}}/calendars/:id
QUERY PARAMS
id
BODY json
{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/calendars/:id" {:content-type :json
                                                         :form-params {:attributes {}
                                                                       :data ""
                                                                       :id 0
                                                                       :name ""}})
require "http/client"

url = "{{baseUrl}}/calendars/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/calendars/:id"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/calendars/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/calendars/:id"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")

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

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

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

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

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

}
PUT /baseUrl/calendars/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/calendars/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/calendars/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/calendars/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/calendars/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  data: '',
  id: 0,
  name: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/calendars/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, data: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/calendars/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"data":"","id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/calendars/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "data": "",\n  "id": 0,\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/calendars/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attributes: {}, data: '', id: 0, name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/calendars/:id',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, data: '', id: 0, name: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  data: '',
  id: 0,
  name: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/calendars/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, data: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/calendars/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"data":"","id":0,"name":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"data": @"",
                              @"id": @0,
                              @"name": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/calendars/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/calendars/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'data' => '',
    'id' => 0,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/calendars/:id', [
  'body' => '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/calendars/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'data' => '',
  'id' => 0,
  'name' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'data' => '',
  'id' => 0,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/calendars/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/calendars/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/calendars/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/calendars/:id"

payload = {
    "attributes": {},
    "data": "",
    "id": 0,
    "name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/calendars/:id"

payload <- "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/calendars/:id') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"data\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "data": "",
        "id": 0,
        "name": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/calendars/:id \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}'
echo '{
  "attributes": {},
  "data": "",
  "id": 0,
  "name": ""
}' |  \
  http PUT {{baseUrl}}/calendars/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "data": "",\n  "id": 0,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/calendars/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "data": "",
  "id": 0,
  "name": ""
] as [String : Any]

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

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

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

dataTask.resume()
POST Create a Saved Command
{{baseUrl}}/commands
BODY json
{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/commands" {:content-type :json
                                                     :form-params {:attributes {}
                                                                   :description ""
                                                                   :deviceId 0
                                                                   :id 0
                                                                   :type ""}})
require "http/client"

url = "{{baseUrl}}/commands"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/commands"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")

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

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

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

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

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

}
POST /baseUrl/commands HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 85

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/commands"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/commands")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/commands")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  description: '',
  deviceId: 0,
  id: 0,
  type: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/commands',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","deviceId":0,"id":0,"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "description": "",\n  "deviceId": 0,\n  "id": 0,\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/commands")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attributes: {}, description: '', deviceId: 0, id: 0, type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/commands',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  description: '',
  deviceId: 0,
  id: 0,
  type: ''
});

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}}/commands',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","deviceId":0,"id":0,"type":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"description": @"",
                              @"deviceId": @0,
                              @"id": @0,
                              @"type": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/commands" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'description' => '',
    'deviceId' => 0,
    'id' => 0,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/commands', [
  'body' => '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/commands');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'deviceId' => 0,
  'id' => 0,
  'type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'deviceId' => 0,
  'id' => 0,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/commands');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/commands"

payload = {
    "attributes": {},
    "description": "",
    "deviceId": 0,
    "id": 0,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands"

payload <- "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/commands")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/commands') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "description": "",
        "deviceId": 0,
        "id": 0,
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/commands \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
echo '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}' |  \
  http POST {{baseUrl}}/commands \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "description": "",\n  "deviceId": 0,\n  "id": 0,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/commands
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()
DELETE Delete a Saved Command
{{baseUrl}}/commands/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/commands/:id")
require "http/client"

url = "{{baseUrl}}/commands/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/commands/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands/:id"

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

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

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

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

}
DELETE /baseUrl/commands/:id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/commands/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/commands/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/commands/:id")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/commands/:id');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/commands/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/commands/:id',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/commands/:id');

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

  console.log(res.body);
});
const axios = require('axios').default;

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands/:id';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/commands/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

let uri = Uri.of_string "{{baseUrl}}/commands/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/commands/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/commands/:id');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/commands/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands/:id' -Method DELETE 
import http.client

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

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

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

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

url = "{{baseUrl}}/commands/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands/:id"

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

content(response, "text")
require 'uri'
require 'net/http'

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

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/commands/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/commands/:id
http DELETE {{baseUrl}}/commands/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/commands/:id
import Foundation

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

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

dataTask.resume()
POST Dispatch commands to device
{{baseUrl}}/commands/send
BODY json
{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/commands/send");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/commands/send" {:content-type :json
                                                          :form-params {:attributes {}
                                                                        :description ""
                                                                        :deviceId 0
                                                                        :id 0
                                                                        :type ""}})
require "http/client"

url = "{{baseUrl}}/commands/send"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/commands/send"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands/send");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands/send"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")

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

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

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

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

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

}
POST /baseUrl/commands/send HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 85

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/commands/send"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/commands/send")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/commands/send")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  description: '',
  deviceId: 0,
  id: 0,
  type: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/commands/send',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands/send';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","deviceId":0,"id":0,"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands/send',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "description": "",\n  "deviceId": 0,\n  "id": 0,\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/commands/send")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attributes: {}, description: '', deviceId: 0, id: 0, type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/commands/send',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/commands/send');

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

req.type('json');
req.send({
  attributes: {},
  description: '',
  deviceId: 0,
  id: 0,
  type: ''
});

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}}/commands/send',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands/send';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","deviceId":0,"id":0,"type":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"description": @"",
                              @"deviceId": @0,
                              @"id": @0,
                              @"type": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/commands/send" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands/send",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'description' => '',
    'deviceId' => 0,
    'id' => 0,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/commands/send', [
  'body' => '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/commands/send');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'deviceId' => 0,
  'id' => 0,
  'type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'deviceId' => 0,
  'id' => 0,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/commands/send');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands/send' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands/send' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

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

conn.request("POST", "/baseUrl/commands/send", payload, headers)

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

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

url = "{{baseUrl}}/commands/send"

payload = {
    "attributes": {},
    "description": "",
    "deviceId": 0,
    "id": 0,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands/send"

payload <- "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/commands/send")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/commands/send') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "description": "",
        "deviceId": 0,
        "id": 0,
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/commands/send \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
echo '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}' |  \
  http POST {{baseUrl}}/commands/send \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "description": "",\n  "deviceId": 0,\n  "id": 0,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/commands/send
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()
GET Fetch a list of Saved Commands supported by Device at the moment
{{baseUrl}}/commands/send
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/commands/send");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/commands/send")
require "http/client"

url = "{{baseUrl}}/commands/send"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/commands/send"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands/send");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands/send"

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

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

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

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

}
GET /baseUrl/commands/send HTTP/1.1
Host: example.com


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/commands/send")
  .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}}/commands/send');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/commands/send'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands/send';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands/send',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/commands/send',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/commands/send'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/commands/send');

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}}/commands/send'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands/send';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/commands/send"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/commands/send" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands/send",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/commands/send');

echo $response->getBody();
setUrl('{{baseUrl}}/commands/send');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/commands/send');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands/send' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands/send' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/commands/send")

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

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

url = "{{baseUrl}}/commands/send"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands/send"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/commands/send")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/commands/send') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/commands/send
http GET {{baseUrl}}/commands/send
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/commands/send
import Foundation

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

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

dataTask.resume()
GET Fetch a list of Saved Commands
{{baseUrl}}/commands
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/commands")
require "http/client"

url = "{{baseUrl}}/commands"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/commands"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands"

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

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

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

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

}
GET /baseUrl/commands HTTP/1.1
Host: example.com


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/commands")
  .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}}/commands');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/commands',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/commands');

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}}/commands'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/commands"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/commands" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/commands');

echo $response->getBody();
setUrl('{{baseUrl}}/commands');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/commands');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/commands")

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

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

url = "{{baseUrl}}/commands"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/commands")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/commands') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/commands
http GET {{baseUrl}}/commands
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/commands
import Foundation

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

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

dataTask.resume()
GET Fetch a list of available Commands for the Device or all possible Commands if Device ommited
{{baseUrl}}/commands/types
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/commands/types");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/commands/types")
require "http/client"

url = "{{baseUrl}}/commands/types"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/commands/types"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands/types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands/types"

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

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

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

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

}
GET /baseUrl/commands/types HTTP/1.1
Host: example.com


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/commands/types")
  .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}}/commands/types');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/commands/types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands/types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands/types',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/commands/types',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/commands/types'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/commands/types');

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}}/commands/types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands/types';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/commands/types"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/commands/types" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands/types",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/commands/types');

echo $response->getBody();
setUrl('{{baseUrl}}/commands/types');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/commands/types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands/types' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands/types' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/commands/types")

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

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

url = "{{baseUrl}}/commands/types"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands/types"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/commands/types")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/commands/types') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/commands/types
http GET {{baseUrl}}/commands/types
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/commands/types
import Foundation

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

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

dataTask.resume()
PUT Update a Saved Command
{{baseUrl}}/commands/:id
QUERY PARAMS
id
BODY json
{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/commands/:id" {:content-type :json
                                                        :form-params {:attributes {}
                                                                      :description ""
                                                                      :deviceId 0
                                                                      :id 0
                                                                      :type ""}})
require "http/client"

url = "{{baseUrl}}/commands/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/commands/:id"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/commands/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/commands/:id"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")

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

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

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

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

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

}
PUT /baseUrl/commands/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 85

{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/commands/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/commands/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/commands/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/commands/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  description: '',
  deviceId: 0,
  id: 0,
  type: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/commands/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/commands/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","deviceId":0,"id":0,"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commands/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "description": "",\n  "deviceId": 0,\n  "id": 0,\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/commands/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attributes: {}, description: '', deviceId: 0, id: 0, type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/commands/:id',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  description: '',
  deviceId: 0,
  id: 0,
  type: ''
});

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}}/commands/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, description: '', deviceId: 0, id: 0, type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/commands/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"description":"","deviceId":0,"id":0,"type":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"description": @"",
                              @"deviceId": @0,
                              @"id": @0,
                              @"type": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/commands/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/commands/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'description' => '',
    'deviceId' => 0,
    'id' => 0,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/commands/:id', [
  'body' => '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/commands/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'deviceId' => 0,
  'id' => 0,
  'type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'description' => '',
  'deviceId' => 0,
  'id' => 0,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/commands/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/commands/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commands/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/commands/:id"

payload = {
    "attributes": {},
    "description": "",
    "deviceId": 0,
    "id": 0,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/commands/:id"

payload <- "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/commands/:id') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"description\": \"\",\n  \"deviceId\": 0,\n  \"id\": 0,\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "description": "",
        "deviceId": 0,
        "id": 0,
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/commands/:id \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}'
echo '{
  "attributes": {},
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
}' |  \
  http PUT {{baseUrl}}/commands/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "description": "",\n  "deviceId": 0,\n  "id": 0,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/commands/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "description": "",
  "deviceId": 0,
  "id": 0,
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()
POST Create a Device
{{baseUrl}}/devices
BODY json
{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/devices" {:content-type :json
                                                    :form-params {:attributes {}
                                                                  :category ""
                                                                  :contact ""
                                                                  :disabled false
                                                                  :geofenceIds []
                                                                  :groupId 0
                                                                  :id 0
                                                                  :lastUpdate ""
                                                                  :model ""
                                                                  :name ""
                                                                  :phone ""
                                                                  :positionId 0
                                                                  :status ""
                                                                  :uniqueId ""}})
require "http/client"

url = "{{baseUrl}}/devices"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/devices"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/devices");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/devices"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")

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

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

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

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

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

}
POST /baseUrl/devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 243

{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/devices")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/devices")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  category: '',
  contact: '',
  disabled: false,
  geofenceIds: [],
  groupId: 0,
  id: 0,
  lastUpdate: '',
  model: '',
  name: '',
  phone: '',
  positionId: 0,
  status: '',
  uniqueId: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/devices',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    category: '',
    contact: '',
    disabled: false,
    geofenceIds: [],
    groupId: 0,
    id: 0,
    lastUpdate: '',
    model: '',
    name: '',
    phone: '',
    positionId: 0,
    status: '',
    uniqueId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"category":"","contact":"","disabled":false,"geofenceIds":[],"groupId":0,"id":0,"lastUpdate":"","model":"","name":"","phone":"","positionId":0,"status":"","uniqueId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "category": "",\n  "contact": "",\n  "disabled": false,\n  "geofenceIds": [],\n  "groupId": 0,\n  "id": 0,\n  "lastUpdate": "",\n  "model": "",\n  "name": "",\n  "phone": "",\n  "positionId": 0,\n  "status": "",\n  "uniqueId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  attributes: {},
  category: '',
  contact: '',
  disabled: false,
  geofenceIds: [],
  groupId: 0,
  id: 0,
  lastUpdate: '',
  model: '',
  name: '',
  phone: '',
  positionId: 0,
  status: '',
  uniqueId: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/devices',
  headers: {'content-type': 'application/json'},
  body: {
    attributes: {},
    category: '',
    contact: '',
    disabled: false,
    geofenceIds: [],
    groupId: 0,
    id: 0,
    lastUpdate: '',
    model: '',
    name: '',
    phone: '',
    positionId: 0,
    status: '',
    uniqueId: ''
  },
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  category: '',
  contact: '',
  disabled: false,
  geofenceIds: [],
  groupId: 0,
  id: 0,
  lastUpdate: '',
  model: '',
  name: '',
  phone: '',
  positionId: 0,
  status: '',
  uniqueId: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/devices',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    category: '',
    contact: '',
    disabled: false,
    geofenceIds: [],
    groupId: 0,
    id: 0,
    lastUpdate: '',
    model: '',
    name: '',
    phone: '',
    positionId: 0,
    status: '',
    uniqueId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"category":"","contact":"","disabled":false,"geofenceIds":[],"groupId":0,"id":0,"lastUpdate":"","model":"","name":"","phone":"","positionId":0,"status":"","uniqueId":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"category": @"",
                              @"contact": @"",
                              @"disabled": @NO,
                              @"geofenceIds": @[  ],
                              @"groupId": @0,
                              @"id": @0,
                              @"lastUpdate": @"",
                              @"model": @"",
                              @"name": @"",
                              @"phone": @"",
                              @"positionId": @0,
                              @"status": @"",
                              @"uniqueId": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'category' => '',
    'contact' => '',
    'disabled' => null,
    'geofenceIds' => [
        
    ],
    'groupId' => 0,
    'id' => 0,
    'lastUpdate' => '',
    'model' => '',
    'name' => '',
    'phone' => '',
    'positionId' => 0,
    'status' => '',
    'uniqueId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/devices', [
  'body' => '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/devices');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'category' => '',
  'contact' => '',
  'disabled' => null,
  'geofenceIds' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'lastUpdate' => '',
  'model' => '',
  'name' => '',
  'phone' => '',
  'positionId' => 0,
  'status' => '',
  'uniqueId' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'category' => '',
  'contact' => '',
  'disabled' => null,
  'geofenceIds' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'lastUpdate' => '',
  'model' => '',
  'name' => '',
  'phone' => '',
  'positionId' => 0,
  'status' => '',
  'uniqueId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/devices');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/devices"

payload = {
    "attributes": {},
    "category": "",
    "contact": "",
    "disabled": False,
    "geofenceIds": [],
    "groupId": 0,
    "id": 0,
    "lastUpdate": "",
    "model": "",
    "name": "",
    "phone": "",
    "positionId": 0,
    "status": "",
    "uniqueId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/devices"

payload <- "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/devices")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/devices') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "category": "",
        "contact": "",
        "disabled": false,
        "geofenceIds": (),
        "groupId": 0,
        "id": 0,
        "lastUpdate": "",
        "model": "",
        "name": "",
        "phone": "",
        "positionId": 0,
        "status": "",
        "uniqueId": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/devices \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}'
echo '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}' |  \
  http POST {{baseUrl}}/devices \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "category": "",\n  "contact": "",\n  "disabled": false,\n  "geofenceIds": [],\n  "groupId": 0,\n  "id": 0,\n  "lastUpdate": "",\n  "model": "",\n  "name": "",\n  "phone": "",\n  "positionId": 0,\n  "status": "",\n  "uniqueId": ""\n}' \
  --output-document \
  - {{baseUrl}}/devices
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
] as [String : Any]

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

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

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

dataTask.resume()
DELETE Delete a Device
{{baseUrl}}/devices/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/devices/:id")
require "http/client"

url = "{{baseUrl}}/devices/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/devices/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/devices/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/devices/:id"

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

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

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

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

}
DELETE /baseUrl/devices/:id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/devices/:id")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/devices/:id');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/devices/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/devices/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/devices/:id',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/devices/:id');

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

  console.log(res.body);
});
const axios = require('axios').default;

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/devices/:id';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/devices/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

let uri = Uri.of_string "{{baseUrl}}/devices/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/devices/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/devices/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/devices/:id');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/devices/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:id' -Method DELETE 
import http.client

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

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

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

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

url = "{{baseUrl}}/devices/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/devices/:id"

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

content(response, "text")
require 'uri'
require 'net/http'

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

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/devices/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/devices/:id
http DELETE {{baseUrl}}/devices/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/devices/:id
import Foundation

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

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

dataTask.resume()
GET Fetch a list of Devices
{{baseUrl}}/devices
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/devices")
require "http/client"

url = "{{baseUrl}}/devices"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/devices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/devices"

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

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

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

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

}
GET /baseUrl/devices HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/devices")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/devices")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/devices');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/devices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/devices',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/devices');

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

  console.log(res.body);
});
const axios = require('axios').default;

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/devices';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/devices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

let uri = Uri.of_string "{{baseUrl}}/devices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/devices');

echo $response->getBody();
setUrl('{{baseUrl}}/devices');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/devices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/devices")

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

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

url = "{{baseUrl}}/devices"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/devices"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/devices")

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

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

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/devices') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/devices
http GET {{baseUrl}}/devices
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/devices
import Foundation

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

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

dataTask.resume()
PUT Update a Device
{{baseUrl}}/devices/:id
QUERY PARAMS
id
BODY json
{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/devices/:id" {:content-type :json
                                                       :form-params {:attributes {}
                                                                     :category ""
                                                                     :contact ""
                                                                     :disabled false
                                                                     :geofenceIds []
                                                                     :groupId 0
                                                                     :id 0
                                                                     :lastUpdate ""
                                                                     :model ""
                                                                     :name ""
                                                                     :phone ""
                                                                     :positionId 0
                                                                     :status ""
                                                                     :uniqueId ""}})
require "http/client"

url = "{{baseUrl}}/devices/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/devices/:id"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/devices/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/devices/:id"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")

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

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

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

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

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

}
PUT /baseUrl/devices/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 243

{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/devices/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/devices/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  category: '',
  contact: '',
  disabled: false,
  geofenceIds: [],
  groupId: 0,
  id: 0,
  lastUpdate: '',
  model: '',
  name: '',
  phone: '',
  positionId: 0,
  status: '',
  uniqueId: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:id',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    category: '',
    contact: '',
    disabled: false,
    geofenceIds: [],
    groupId: 0,
    id: 0,
    lastUpdate: '',
    model: '',
    name: '',
    phone: '',
    positionId: 0,
    status: '',
    uniqueId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/devices/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"category":"","contact":"","disabled":false,"geofenceIds":[],"groupId":0,"id":0,"lastUpdate":"","model":"","name":"","phone":"","positionId":0,"status":"","uniqueId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "category": "",\n  "contact": "",\n  "disabled": false,\n  "geofenceIds": [],\n  "groupId": 0,\n  "id": 0,\n  "lastUpdate": "",\n  "model": "",\n  "name": "",\n  "phone": "",\n  "positionId": 0,\n  "status": "",\n  "uniqueId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  attributes: {},
  category: '',
  contact: '',
  disabled: false,
  geofenceIds: [],
  groupId: 0,
  id: 0,
  lastUpdate: '',
  model: '',
  name: '',
  phone: '',
  positionId: 0,
  status: '',
  uniqueId: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:id',
  headers: {'content-type': 'application/json'},
  body: {
    attributes: {},
    category: '',
    contact: '',
    disabled: false,
    geofenceIds: [],
    groupId: 0,
    id: 0,
    lastUpdate: '',
    model: '',
    name: '',
    phone: '',
    positionId: 0,
    status: '',
    uniqueId: ''
  },
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  category: '',
  contact: '',
  disabled: false,
  geofenceIds: [],
  groupId: 0,
  id: 0,
  lastUpdate: '',
  model: '',
  name: '',
  phone: '',
  positionId: 0,
  status: '',
  uniqueId: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:id',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    category: '',
    contact: '',
    disabled: false,
    geofenceIds: [],
    groupId: 0,
    id: 0,
    lastUpdate: '',
    model: '',
    name: '',
    phone: '',
    positionId: 0,
    status: '',
    uniqueId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/devices/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"category":"","contact":"","disabled":false,"geofenceIds":[],"groupId":0,"id":0,"lastUpdate":"","model":"","name":"","phone":"","positionId":0,"status":"","uniqueId":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"category": @"",
                              @"contact": @"",
                              @"disabled": @NO,
                              @"geofenceIds": @[  ],
                              @"groupId": @0,
                              @"id": @0,
                              @"lastUpdate": @"",
                              @"model": @"",
                              @"name": @"",
                              @"phone": @"",
                              @"positionId": @0,
                              @"status": @"",
                              @"uniqueId": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/devices/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/devices/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'category' => '',
    'contact' => '',
    'disabled' => null,
    'geofenceIds' => [
        
    ],
    'groupId' => 0,
    'id' => 0,
    'lastUpdate' => '',
    'model' => '',
    'name' => '',
    'phone' => '',
    'positionId' => 0,
    'status' => '',
    'uniqueId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/devices/:id', [
  'body' => '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/devices/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'category' => '',
  'contact' => '',
  'disabled' => null,
  'geofenceIds' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'lastUpdate' => '',
  'model' => '',
  'name' => '',
  'phone' => '',
  'positionId' => 0,
  'status' => '',
  'uniqueId' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'category' => '',
  'contact' => '',
  'disabled' => null,
  'geofenceIds' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'lastUpdate' => '',
  'model' => '',
  'name' => '',
  'phone' => '',
  'positionId' => 0,
  'status' => '',
  'uniqueId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/devices/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/devices/:id"

payload = {
    "attributes": {},
    "category": "",
    "contact": "",
    "disabled": False,
    "geofenceIds": [],
    "groupId": 0,
    "id": 0,
    "lastUpdate": "",
    "model": "",
    "name": "",
    "phone": "",
    "positionId": 0,
    "status": "",
    "uniqueId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/devices/:id"

payload <- "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/devices/:id') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"category\": \"\",\n  \"contact\": \"\",\n  \"disabled\": false,\n  \"geofenceIds\": [],\n  \"groupId\": 0,\n  \"id\": 0,\n  \"lastUpdate\": \"\",\n  \"model\": \"\",\n  \"name\": \"\",\n  \"phone\": \"\",\n  \"positionId\": 0,\n  \"status\": \"\",\n  \"uniqueId\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "category": "",
        "contact": "",
        "disabled": false,
        "geofenceIds": (),
        "groupId": 0,
        "id": 0,
        "lastUpdate": "",
        "model": "",
        "name": "",
        "phone": "",
        "positionId": 0,
        "status": "",
        "uniqueId": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/devices/:id \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}'
echo '{
  "attributes": {},
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
}' |  \
  http PUT {{baseUrl}}/devices/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "category": "",\n  "contact": "",\n  "disabled": false,\n  "geofenceIds": [],\n  "groupId": 0,\n  "id": 0,\n  "lastUpdate": "",\n  "model": "",\n  "name": "",\n  "phone": "",\n  "positionId": 0,\n  "status": "",\n  "uniqueId": ""\n}' \
  --output-document \
  - {{baseUrl}}/devices/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "category": "",
  "contact": "",
  "disabled": false,
  "geofenceIds": [],
  "groupId": 0,
  "id": 0,
  "lastUpdate": "",
  "model": "",
  "name": "",
  "phone": "",
  "positionId": 0,
  "status": "",
  "uniqueId": ""
] as [String : Any]

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

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

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

dataTask.resume()
PUT Update total distance and hours of the Device
{{baseUrl}}/devices/:id/accumulators
QUERY PARAMS
id
BODY json
{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/devices/:id/accumulators" {:content-type :json
                                                                    :form-params {:deviceId 0
                                                                                  :hours ""
                                                                                  :totalDistance ""}})
require "http/client"

url = "{{baseUrl}}/devices/:id/accumulators"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/devices/:id/accumulators"),
    Content = new StringContent("{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/devices/:id/accumulators");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/devices/:id/accumulators"

	payload := strings.NewReader("{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}")

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

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

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

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

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

}
PUT /baseUrl/devices/:id/accumulators HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/devices/:id/accumulators")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/devices/:id/accumulators"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/devices/:id/accumulators")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/devices/:id/accumulators")
  .header("content-type", "application/json")
  .body("{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  deviceId: 0,
  hours: '',
  totalDistance: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:id/accumulators',
  headers: {'content-type': 'application/json'},
  data: {deviceId: 0, hours: '', totalDistance: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/devices/:id/accumulators';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"deviceId":0,"hours":"","totalDistance":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/devices/:id/accumulators',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deviceId": 0,\n  "hours": "",\n  "totalDistance": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/devices/:id/accumulators")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({deviceId: 0, hours: '', totalDistance: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:id/accumulators',
  headers: {'content-type': 'application/json'},
  body: {deviceId: 0, hours: '', totalDistance: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  deviceId: 0,
  hours: '',
  totalDistance: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/devices/:id/accumulators',
  headers: {'content-type': 'application/json'},
  data: {deviceId: 0, hours: '', totalDistance: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/devices/:id/accumulators';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"deviceId":0,"hours":"","totalDistance":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"deviceId": @0,
                              @"hours": @"",
                              @"totalDistance": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/devices/:id/accumulators"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

let uri = Uri.of_string "{{baseUrl}}/devices/:id/accumulators" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/devices/:id/accumulators",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'deviceId' => 0,
    'hours' => '',
    'totalDistance' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/devices/:id/accumulators', [
  'body' => '{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/devices/:id/accumulators');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deviceId' => 0,
  'hours' => '',
  'totalDistance' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'deviceId' => 0,
  'hours' => '',
  'totalDistance' => ''
]));
$request->setRequestUrl('{{baseUrl}}/devices/:id/accumulators');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/devices/:id/accumulators' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/devices/:id/accumulators' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}'
import http.client

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

payload = "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/devices/:id/accumulators", payload, headers)

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

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

url = "{{baseUrl}}/devices/:id/accumulators"

payload = {
    "deviceId": 0,
    "hours": "",
    "totalDistance": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/devices/:id/accumulators"

payload <- "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/devices/:id/accumulators")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/devices/:id/accumulators') do |req|
  req.body = "{\n  \"deviceId\": 0,\n  \"hours\": \"\",\n  \"totalDistance\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "deviceId": 0,
        "hours": "",
        "totalDistance": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/devices/:id/accumulators \
  --header 'content-type: application/json' \
  --data '{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}'
echo '{
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
}' |  \
  http PUT {{baseUrl}}/devices/:id/accumulators \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "deviceId": 0,\n  "hours": "",\n  "totalDistance": ""\n}' \
  --output-document \
  - {{baseUrl}}/devices/:id/accumulators
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "deviceId": 0,
  "hours": "",
  "totalDistance": ""
] as [String : Any]

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

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

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

dataTask.resume()
POST Create a Driver
{{baseUrl}}/drivers
BODY json
{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/drivers" {:content-type :json
                                                    :form-params {:attributes {}
                                                                  :id 0
                                                                  :name ""
                                                                  :uniqueId ""}})
require "http/client"

url = "{{baseUrl}}/drivers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/drivers"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/drivers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/drivers"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")

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

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

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

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

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

}
POST /baseUrl/drivers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/drivers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/drivers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/drivers")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  id: 0,
  name: '',
  uniqueId: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/drivers',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', uniqueId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/drivers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","uniqueId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/drivers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "uniqueId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/drivers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

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

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

req.write(JSON.stringify({attributes: {}, id: 0, name: '', uniqueId: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/drivers',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, id: 0, name: '', uniqueId: ''},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

req.type('json');
req.send({
  attributes: {},
  id: 0,
  name: '',
  uniqueId: ''
});

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}}/drivers',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', uniqueId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/drivers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","uniqueId":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"id": @0,
                              @"name": @"",
                              @"uniqueId": @"" };

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

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

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

let uri = Uri.of_string "{{baseUrl}}/drivers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/drivers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'id' => 0,
    'name' => '',
    'uniqueId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/drivers', [
  'body' => '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/drivers');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'uniqueId' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'uniqueId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/drivers');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/drivers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/drivers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}'
import http.client

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

payload = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/drivers"

payload = {
    "attributes": {},
    "id": 0,
    "name": "",
    "uniqueId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/drivers"

payload <- "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/drivers")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/drivers') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "attributes": json!({}),
        "id": 0,
        "name": "",
        "uniqueId": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/drivers \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}'
echo '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}' |  \
  http POST {{baseUrl}}/drivers \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "uniqueId": ""\n}' \
  --output-document \
  - {{baseUrl}}/drivers
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "id": 0,
  "name": "",
  "uniqueId": ""
] as [String : Any]

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

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

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

dataTask.resume()
DELETE Delete a Driver
{{baseUrl}}/drivers/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/drivers/:id")
require "http/client"

url = "{{baseUrl}}/drivers/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/drivers/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/drivers/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/drivers/:id"

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

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

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

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

}
DELETE /baseUrl/drivers/:id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/drivers/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/drivers/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/drivers/:id")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/drivers/:id');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/drivers/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/drivers/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/drivers/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/drivers/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/drivers/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/drivers/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/drivers/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/drivers/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/drivers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/drivers/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/drivers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/drivers/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/drivers/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/drivers/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/drivers/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/drivers/:id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/drivers/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/drivers/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/drivers/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/drivers/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/drivers/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/drivers/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/drivers/:id
http DELETE {{baseUrl}}/drivers/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/drivers/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/drivers/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Drivers
{{baseUrl}}/drivers
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/drivers");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/drivers")
require "http/client"

url = "{{baseUrl}}/drivers"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/drivers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/drivers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/drivers"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/drivers HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/drivers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/drivers"))
    .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}}/drivers")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/drivers")
  .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}}/drivers');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/drivers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/drivers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/drivers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/drivers")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/drivers',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/drivers'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/drivers');

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}}/drivers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/drivers';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/drivers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/drivers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/drivers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/drivers');

echo $response->getBody();
setUrl('{{baseUrl}}/drivers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/drivers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/drivers' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/drivers' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/drivers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/drivers"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/drivers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/drivers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/drivers') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/drivers";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/drivers
http GET {{baseUrl}}/drivers
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/drivers
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/drivers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update a Driver
{{baseUrl}}/drivers/:id
QUERY PARAMS
id
BODY json
{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/drivers/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/drivers/:id" {:content-type :json
                                                       :form-params {:attributes {}
                                                                     :id 0
                                                                     :name ""
                                                                     :uniqueId ""}})
require "http/client"

url = "{{baseUrl}}/drivers/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/drivers/:id"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/drivers/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/drivers/:id"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/drivers/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/drivers/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/drivers/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/drivers/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/drivers/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  id: 0,
  name: '',
  uniqueId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/drivers/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/drivers/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', uniqueId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/drivers/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","uniqueId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/drivers/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "uniqueId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/drivers/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/drivers/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({attributes: {}, id: 0, name: '', uniqueId: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/drivers/:id',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, id: 0, name: '', uniqueId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/drivers/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  id: 0,
  name: '',
  uniqueId: ''
});

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}}/drivers/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', uniqueId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/drivers/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","uniqueId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"id": @0,
                              @"name": @"",
                              @"uniqueId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/drivers/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/drivers/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/drivers/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'id' => 0,
    'name' => '',
    'uniqueId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/drivers/:id', [
  'body' => '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/drivers/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'uniqueId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'uniqueId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/drivers/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/drivers/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/drivers/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/drivers/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/drivers/:id"

payload = {
    "attributes": {},
    "id": 0,
    "name": "",
    "uniqueId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/drivers/:id"

payload <- "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/drivers/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/drivers/:id') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"uniqueId\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/drivers/:id";

    let payload = json!({
        "attributes": json!({}),
        "id": 0,
        "name": "",
        "uniqueId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/drivers/:id \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}'
echo '{
  "attributes": {},
  "id": 0,
  "name": "",
  "uniqueId": ""
}' |  \
  http PUT {{baseUrl}}/drivers/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "uniqueId": ""\n}' \
  --output-document \
  - {{baseUrl}}/drivers/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "id": 0,
  "name": "",
  "uniqueId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/drivers/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET get -events--id
{{baseUrl}}/events/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events/:id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/events/:id")
require "http/client"

url = "{{baseUrl}}/events/:id"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/events/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/events/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/events/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/events/:id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/events/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/events/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/events/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/events/:id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/events/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/events/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/events/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/events/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/events/:id")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/events/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/events/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/events/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/events/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/events/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/events/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/events/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/events/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/events/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/events/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/events/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/events/:id' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/events/:id' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/events/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/events/:id"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/events/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/events/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/events/:id') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/events/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/events/:id
http GET {{baseUrl}}/events/:id
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/events/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/events/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a Geofence
{{baseUrl}}/geofences
BODY json
{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/geofences");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/geofences" {:content-type :json
                                                      :form-params {:area ""
                                                                    :attributes {}
                                                                    :calendarId 0
                                                                    :description ""
                                                                    :id 0
                                                                    :name ""}})
require "http/client"

url = "{{baseUrl}}/geofences"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/geofences"),
    Content = new StringContent("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/geofences");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/geofences"

	payload := strings.NewReader("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/geofences HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 101

{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/geofences")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/geofences"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/geofences")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/geofences")
  .header("content-type", "application/json")
  .body("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  area: '',
  attributes: {},
  calendarId: 0,
  description: '',
  id: 0,
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/geofences');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/geofences',
  headers: {'content-type': 'application/json'},
  data: {area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/geofences';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"area":"","attributes":{},"calendarId":0,"description":"","id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/geofences',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "area": "",\n  "attributes": {},\n  "calendarId": 0,\n  "description": "",\n  "id": 0,\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/geofences")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/geofences',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/geofences',
  headers: {'content-type': 'application/json'},
  body: {area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/geofences');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  area: '',
  attributes: {},
  calendarId: 0,
  description: '',
  id: 0,
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/geofences',
  headers: {'content-type': 'application/json'},
  data: {area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/geofences';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"area":"","attributes":{},"calendarId":0,"description":"","id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"area": @"",
                              @"attributes": @{  },
                              @"calendarId": @0,
                              @"description": @"",
                              @"id": @0,
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/geofences"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/geofences" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/geofences",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'area' => '',
    'attributes' => [
        
    ],
    'calendarId' => 0,
    'description' => '',
    'id' => 0,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/geofences', [
  'body' => '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/geofences');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'area' => '',
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'description' => '',
  'id' => 0,
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'area' => '',
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'description' => '',
  'id' => 0,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/geofences');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/geofences' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/geofences' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/geofences", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/geofences"

payload = {
    "area": "",
    "attributes": {},
    "calendarId": 0,
    "description": "",
    "id": 0,
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/geofences"

payload <- "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/geofences")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/geofences') do |req|
  req.body = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/geofences";

    let payload = json!({
        "area": "",
        "attributes": json!({}),
        "calendarId": 0,
        "description": "",
        "id": 0,
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/geofences \
  --header 'content-type: application/json' \
  --data '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}'
echo '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}' |  \
  http POST {{baseUrl}}/geofences \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "area": "",\n  "attributes": {},\n  "calendarId": 0,\n  "description": "",\n  "id": 0,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/geofences
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "area": "",
  "attributes": [],
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/geofences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete a Geofence
{{baseUrl}}/geofences/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/geofences/:id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/geofences/:id")
require "http/client"

url = "{{baseUrl}}/geofences/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/geofences/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/geofences/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/geofences/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/geofences/:id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/geofences/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/geofences/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/geofences/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/geofences/:id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/geofences/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/geofences/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/geofences/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/geofences/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/geofences/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/geofences/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/geofences/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/geofences/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/geofences/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/geofences/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/geofences/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/geofences/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/geofences/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/geofences/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/geofences/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/geofences/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/geofences/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/geofences/:id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/geofences/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/geofences/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/geofences/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/geofences/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/geofences/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/geofences/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/geofences/:id
http DELETE {{baseUrl}}/geofences/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/geofences/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/geofences/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Geofences
{{baseUrl}}/geofences
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/geofences");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/geofences")
require "http/client"

url = "{{baseUrl}}/geofences"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/geofences"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/geofences");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/geofences"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/geofences HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/geofences")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/geofences"))
    .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}}/geofences")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/geofences")
  .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}}/geofences');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/geofences'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/geofences';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/geofences',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/geofences")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/geofences',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/geofences'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/geofences');

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}}/geofences'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/geofences';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/geofences"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/geofences" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/geofences",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/geofences');

echo $response->getBody();
setUrl('{{baseUrl}}/geofences');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/geofences');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/geofences' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/geofences' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/geofences")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/geofences"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/geofences"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/geofences")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/geofences') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/geofences";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/geofences
http GET {{baseUrl}}/geofences
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/geofences
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/geofences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update a Geofence
{{baseUrl}}/geofences/:id
QUERY PARAMS
id
BODY json
{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/geofences/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/geofences/:id" {:content-type :json
                                                         :form-params {:area ""
                                                                       :attributes {}
                                                                       :calendarId 0
                                                                       :description ""
                                                                       :id 0
                                                                       :name ""}})
require "http/client"

url = "{{baseUrl}}/geofences/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/geofences/:id"),
    Content = new StringContent("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/geofences/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/geofences/:id"

	payload := strings.NewReader("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/geofences/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 101

{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/geofences/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/geofences/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/geofences/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/geofences/:id")
  .header("content-type", "application/json")
  .body("{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  area: '',
  attributes: {},
  calendarId: 0,
  description: '',
  id: 0,
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/geofences/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/geofences/:id',
  headers: {'content-type': 'application/json'},
  data: {area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/geofences/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"area":"","attributes":{},"calendarId":0,"description":"","id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/geofences/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "area": "",\n  "attributes": {},\n  "calendarId": 0,\n  "description": "",\n  "id": 0,\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/geofences/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/geofences/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/geofences/:id',
  headers: {'content-type': 'application/json'},
  body: {area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/geofences/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  area: '',
  attributes: {},
  calendarId: 0,
  description: '',
  id: 0,
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/geofences/:id',
  headers: {'content-type': 'application/json'},
  data: {area: '', attributes: {}, calendarId: 0, description: '', id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/geofences/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"area":"","attributes":{},"calendarId":0,"description":"","id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"area": @"",
                              @"attributes": @{  },
                              @"calendarId": @0,
                              @"description": @"",
                              @"id": @0,
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/geofences/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/geofences/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/geofences/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'area' => '',
    'attributes' => [
        
    ],
    'calendarId' => 0,
    'description' => '',
    'id' => 0,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/geofences/:id', [
  'body' => '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/geofences/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'area' => '',
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'description' => '',
  'id' => 0,
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'area' => '',
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'description' => '',
  'id' => 0,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/geofences/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/geofences/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/geofences/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/geofences/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/geofences/:id"

payload = {
    "area": "",
    "attributes": {},
    "calendarId": 0,
    "description": "",
    "id": 0,
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/geofences/:id"

payload <- "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/geofences/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/geofences/:id') do |req|
  req.body = "{\n  \"area\": \"\",\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"description\": \"\",\n  \"id\": 0,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/geofences/:id";

    let payload = json!({
        "area": "",
        "attributes": json!({}),
        "calendarId": 0,
        "description": "",
        "id": 0,
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/geofences/:id \
  --header 'content-type: application/json' \
  --data '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}'
echo '{
  "area": "",
  "attributes": {},
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
}' |  \
  http PUT {{baseUrl}}/geofences/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "area": "",\n  "attributes": {},\n  "calendarId": 0,\n  "description": "",\n  "id": 0,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/geofences/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "area": "",
  "attributes": [],
  "calendarId": 0,
  "description": "",
  "id": 0,
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/geofences/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a Group
{{baseUrl}}/groups
BODY json
{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/groups" {:content-type :json
                                                   :form-params {:attributes {}
                                                                 :groupId 0
                                                                 :id 0
                                                                 :name ""}})
require "http/client"

url = "{{baseUrl}}/groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/groups"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/groups")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  groupId: 0,
  id: 0,
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, groupId: 0, id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"groupId":0,"id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "groupId": 0,\n  "id": 0,\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({attributes: {}, groupId: 0, id: 0, name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, groupId: 0, id: 0, name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/groups');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  groupId: 0,
  id: 0,
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, groupId: 0, id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"groupId":0,"id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"groupId": @0,
                              @"id": @0,
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'groupId' => 0,
    'id' => 0,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/groups', [
  'body' => '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/groups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/groups');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/groups", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/groups"

payload = {
    "attributes": {},
    "groupId": 0,
    "id": 0,
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/groups"

payload <- "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/groups') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups";

    let payload = json!({
        "attributes": json!({}),
        "groupId": 0,
        "id": 0,
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}'
echo '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}' |  \
  http POST {{baseUrl}}/groups \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "groupId": 0,\n  "id": 0,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/groups
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "groupId": 0,
  "id": 0,
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete a Group
{{baseUrl}}/groups/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/groups/:id")
require "http/client"

url = "{{baseUrl}}/groups/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/groups/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/groups/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/groups/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/groups/:id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/groups/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/groups/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/groups/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/groups/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/groups/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/groups/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/groups/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/groups/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/groups/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/groups/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/groups/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/groups/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/groups/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/groups/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/groups/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/groups/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/groups/:id
http DELETE {{baseUrl}}/groups/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/groups/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Groups
{{baseUrl}}/groups
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/groups")
require "http/client"

url = "{{baseUrl}}/groups"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/groups"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/groups HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups"))
    .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}}/groups")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/groups")
  .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}}/groups');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/groups'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups');

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}}/groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/groups');

echo $response->getBody();
setUrl('{{baseUrl}}/groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/groups"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/groups
http GET {{baseUrl}}/groups
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/groups
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update a Group
{{baseUrl}}/groups/:id
QUERY PARAMS
id
BODY json
{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/groups/:id" {:content-type :json
                                                      :form-params {:attributes {}
                                                                    :groupId 0
                                                                    :id 0
                                                                    :name ""}})
require "http/client"

url = "{{baseUrl}}/groups/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/groups/:id"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/groups/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/groups/:id"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/groups/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/groups/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/groups/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/groups/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  groupId: 0,
  id: 0,
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/groups/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, groupId: 0, id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/groups/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"groupId":0,"id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/groups/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "groupId": 0,\n  "id": 0,\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/groups/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({attributes: {}, groupId: 0, id: 0, name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:id',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, groupId: 0, id: 0, name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/groups/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  groupId: 0,
  id: 0,
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, groupId: 0, id: 0, name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"groupId":0,"id":0,"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"groupId": @0,
                              @"id": @0,
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/groups/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'groupId' => 0,
    'id' => 0,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/groups/:id', [
  'body' => '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/groups/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'groupId' => 0,
  'id' => 0,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/groups/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/groups/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/groups/:id"

payload = {
    "attributes": {},
    "groupId": 0,
    "id": 0,
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/groups/:id"

payload <- "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/groups/:id') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"groupId\": 0,\n  \"id\": 0,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:id";

    let payload = json!({
        "attributes": json!({}),
        "groupId": 0,
        "id": 0,
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/groups/:id \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}'
echo '{
  "attributes": {},
  "groupId": 0,
  "id": 0,
  "name": ""
}' |  \
  http PUT {{baseUrl}}/groups/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "groupId": 0,\n  "id": 0,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/groups/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "groupId": 0,
  "id": 0,
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a Maintenance
{{baseUrl}}/maintenance
BODY json
{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/maintenance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/maintenance" {:content-type :json
                                                        :form-params {:attributes {}
                                                                      :id 0
                                                                      :name ""
                                                                      :period ""
                                                                      :start ""
                                                                      :type ""}})
require "http/client"

url = "{{baseUrl}}/maintenance"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/maintenance"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/maintenance");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/maintenance"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/maintenance HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/maintenance")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/maintenance"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/maintenance")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/maintenance")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  id: 0,
  name: '',
  period: '',
  start: '',
  type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/maintenance');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/maintenance',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', period: '', start: '', type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/maintenance';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","period":"","start":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/maintenance',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "period": "",\n  "start": "",\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/maintenance")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/maintenance',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({attributes: {}, id: 0, name: '', period: '', start: '', type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/maintenance',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, id: 0, name: '', period: '', start: '', type: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/maintenance');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  id: 0,
  name: '',
  period: '',
  start: '',
  type: ''
});

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}}/maintenance',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', period: '', start: '', type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/maintenance';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","period":"","start":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"id": @0,
                              @"name": @"",
                              @"period": @"",
                              @"start": @"",
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/maintenance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/maintenance" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/maintenance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'id' => 0,
    'name' => '',
    'period' => '',
    'start' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/maintenance', [
  'body' => '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/maintenance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'period' => '',
  'start' => '',
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'period' => '',
  'start' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/maintenance');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/maintenance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/maintenance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/maintenance", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/maintenance"

payload = {
    "attributes": {},
    "id": 0,
    "name": "",
    "period": "",
    "start": "",
    "type": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/maintenance"

payload <- "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/maintenance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/maintenance') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/maintenance";

    let payload = json!({
        "attributes": json!({}),
        "id": 0,
        "name": "",
        "period": "",
        "start": "",
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/maintenance \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}'
echo '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}' |  \
  http POST {{baseUrl}}/maintenance \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "period": "",\n  "start": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/maintenance
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/maintenance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete a Maintenance
{{baseUrl}}/maintenance/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/maintenance/:id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/maintenance/:id")
require "http/client"

url = "{{baseUrl}}/maintenance/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/maintenance/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/maintenance/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/maintenance/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/maintenance/:id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/maintenance/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/maintenance/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/maintenance/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/maintenance/:id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/maintenance/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/maintenance/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/maintenance/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/maintenance/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/maintenance/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/maintenance/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/maintenance/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/maintenance/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/maintenance/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/maintenance/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/maintenance/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/maintenance/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/maintenance/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/maintenance/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/maintenance/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/maintenance/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/maintenance/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/maintenance/:id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/maintenance/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/maintenance/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/maintenance/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/maintenance/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/maintenance/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/maintenance/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/maintenance/:id
http DELETE {{baseUrl}}/maintenance/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/maintenance/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/maintenance/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Maintenance
{{baseUrl}}/maintenance
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/maintenance");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/maintenance")
require "http/client"

url = "{{baseUrl}}/maintenance"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/maintenance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/maintenance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/maintenance"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/maintenance HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/maintenance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/maintenance"))
    .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}}/maintenance")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/maintenance")
  .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}}/maintenance');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/maintenance'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/maintenance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/maintenance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/maintenance")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/maintenance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/maintenance'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/maintenance');

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}}/maintenance'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/maintenance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/maintenance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/maintenance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/maintenance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/maintenance');

echo $response->getBody();
setUrl('{{baseUrl}}/maintenance');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/maintenance');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/maintenance' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/maintenance' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/maintenance")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/maintenance"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/maintenance"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/maintenance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/maintenance') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/maintenance";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/maintenance
http GET {{baseUrl}}/maintenance
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/maintenance
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/maintenance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update a Maintenance
{{baseUrl}}/maintenance/:id
QUERY PARAMS
id
BODY json
{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/maintenance/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/maintenance/:id" {:content-type :json
                                                           :form-params {:attributes {}
                                                                         :id 0
                                                                         :name ""
                                                                         :period ""
                                                                         :start ""
                                                                         :type ""}})
require "http/client"

url = "{{baseUrl}}/maintenance/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/maintenance/:id"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/maintenance/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/maintenance/:id"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/maintenance/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/maintenance/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/maintenance/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/maintenance/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/maintenance/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  id: 0,
  name: '',
  period: '',
  start: '',
  type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/maintenance/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/maintenance/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', period: '', start: '', type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/maintenance/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","period":"","start":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/maintenance/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "period": "",\n  "start": "",\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/maintenance/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/maintenance/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({attributes: {}, id: 0, name: '', period: '', start: '', type: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/maintenance/:id',
  headers: {'content-type': 'application/json'},
  body: {attributes: {}, id: 0, name: '', period: '', start: '', type: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/maintenance/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  id: 0,
  name: '',
  period: '',
  start: '',
  type: ''
});

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}}/maintenance/:id',
  headers: {'content-type': 'application/json'},
  data: {attributes: {}, id: 0, name: '', period: '', start: '', type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/maintenance/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"id":0,"name":"","period":"","start":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"id": @0,
                              @"name": @"",
                              @"period": @"",
                              @"start": @"",
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/maintenance/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/maintenance/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/maintenance/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'id' => 0,
    'name' => '',
    'period' => '',
    'start' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/maintenance/:id', [
  'body' => '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/maintenance/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'period' => '',
  'start' => '',
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'id' => 0,
  'name' => '',
  'period' => '',
  'start' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/maintenance/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/maintenance/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/maintenance/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/maintenance/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/maintenance/:id"

payload = {
    "attributes": {},
    "id": 0,
    "name": "",
    "period": "",
    "start": "",
    "type": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/maintenance/:id"

payload <- "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/maintenance/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/maintenance/:id') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"id\": 0,\n  \"name\": \"\",\n  \"period\": \"\",\n  \"start\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/maintenance/:id";

    let payload = json!({
        "attributes": json!({}),
        "id": 0,
        "name": "",
        "period": "",
        "start": "",
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/maintenance/:id \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}'
echo '{
  "attributes": {},
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
}' |  \
  http PUT {{baseUrl}}/maintenance/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "id": 0,\n  "name": "",\n  "period": "",\n  "start": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/maintenance/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "id": 0,
  "name": "",
  "period": "",
  "start": "",
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/maintenance/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a Notification
{{baseUrl}}/notifications
BODY json
{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/notifications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/notifications" {:content-type :json
                                                          :form-params {:always false
                                                                        :attributes {}
                                                                        :calendarId 0
                                                                        :id 0
                                                                        :mail false
                                                                        :sms false
                                                                        :type ""
                                                                        :web false}})
require "http/client"

url = "{{baseUrl}}/notifications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/notifications"),
    Content = new StringContent("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/notifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/notifications"

	payload := strings.NewReader("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/notifications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/notifications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/notifications")
  .header("content-type", "application/json")
  .body("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
  .asString();
const data = JSON.stringify({
  always: false,
  attributes: {},
  calendarId: 0,
  id: 0,
  mail: false,
  sms: false,
  type: '',
  web: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/notifications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/notifications',
  headers: {'content-type': 'application/json'},
  data: {
    always: false,
    attributes: {},
    calendarId: 0,
    id: 0,
    mail: false,
    sms: false,
    type: '',
    web: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"always":false,"attributes":{},"calendarId":0,"id":0,"mail":false,"sms":false,"type":"","web":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "always": false,\n  "attributes": {},\n  "calendarId": 0,\n  "id": 0,\n  "mail": false,\n  "sms": false,\n  "type": "",\n  "web": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/notifications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  always: false,
  attributes: {},
  calendarId: 0,
  id: 0,
  mail: false,
  sms: false,
  type: '',
  web: false
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/notifications',
  headers: {'content-type': 'application/json'},
  body: {
    always: false,
    attributes: {},
    calendarId: 0,
    id: 0,
    mail: false,
    sms: false,
    type: '',
    web: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/notifications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  always: false,
  attributes: {},
  calendarId: 0,
  id: 0,
  mail: false,
  sms: false,
  type: '',
  web: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/notifications',
  headers: {'content-type': 'application/json'},
  data: {
    always: false,
    attributes: {},
    calendarId: 0,
    id: 0,
    mail: false,
    sms: false,
    type: '',
    web: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"always":false,"attributes":{},"calendarId":0,"id":0,"mail":false,"sms":false,"type":"","web":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"always": @NO,
                              @"attributes": @{  },
                              @"calendarId": @0,
                              @"id": @0,
                              @"mail": @NO,
                              @"sms": @NO,
                              @"type": @"",
                              @"web": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'always' => null,
    'attributes' => [
        
    ],
    'calendarId' => 0,
    'id' => 0,
    'mail' => null,
    'sms' => null,
    'type' => '',
    'web' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/notifications', [
  'body' => '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/notifications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'always' => null,
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'id' => 0,
  'mail' => null,
  'sms' => null,
  'type' => '',
  'web' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'always' => null,
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'id' => 0,
  'mail' => null,
  'sms' => null,
  'type' => '',
  'web' => null
]));
$request->setRequestUrl('{{baseUrl}}/notifications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/notifications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/notifications"

payload = {
    "always": False,
    "attributes": {},
    "calendarId": 0,
    "id": 0,
    "mail": False,
    "sms": False,
    "type": "",
    "web": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/notifications"

payload <- "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/notifications') do |req|
  req.body = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/notifications";

    let payload = json!({
        "always": false,
        "attributes": json!({}),
        "calendarId": 0,
        "id": 0,
        "mail": false,
        "sms": false,
        "type": "",
        "web": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/notifications \
  --header 'content-type: application/json' \
  --data '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}'
echo '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}' |  \
  http POST {{baseUrl}}/notifications \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "always": false,\n  "attributes": {},\n  "calendarId": 0,\n  "id": 0,\n  "mail": false,\n  "sms": false,\n  "type": "",\n  "web": false\n}' \
  --output-document \
  - {{baseUrl}}/notifications
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "always": false,
  "attributes": [],
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete a Notification
{{baseUrl}}/notifications/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/notifications/:id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/notifications/:id")
require "http/client"

url = "{{baseUrl}}/notifications/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/notifications/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/notifications/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/notifications/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/notifications/:id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/notifications/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/notifications/:id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/notifications/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/notifications/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/notifications/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/notifications/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/notifications/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/notifications/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/notifications/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/notifications/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/notifications/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/notifications/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/notifications/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/:id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/notifications/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/notifications/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/notifications/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/notifications/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/notifications/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/notifications/:id
http DELETE {{baseUrl}}/notifications/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/notifications/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Notifications
{{baseUrl}}/notifications
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/notifications");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/notifications")
require "http/client"

url = "{{baseUrl}}/notifications"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/notifications"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/notifications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/notifications"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/notifications HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/notifications")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications"))
    .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}}/notifications")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/notifications")
  .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}}/notifications');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/notifications'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/notifications';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/notifications'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/notifications');

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}}/notifications'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/notifications';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/notifications');

echo $response->getBody();
setUrl('{{baseUrl}}/notifications');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/notifications');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/notifications")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/notifications"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/notifications"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/notifications') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/notifications";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/notifications
http GET {{baseUrl}}/notifications
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/notifications
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of available Notification types
{{baseUrl}}/notifications/types
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/notifications/types");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/notifications/types")
require "http/client"

url = "{{baseUrl}}/notifications/types"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/notifications/types"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/notifications/types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/notifications/types"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/notifications/types HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/notifications/types")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/types"))
    .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}}/notifications/types")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/notifications/types")
  .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}}/notifications/types');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/notifications/types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/notifications/types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/types',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications/types")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications/types',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/notifications/types'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/notifications/types');

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}}/notifications/types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/notifications/types';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/types"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications/types" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/notifications/types",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/notifications/types');

echo $response->getBody();
setUrl('{{baseUrl}}/notifications/types');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/notifications/types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/types' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/types' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/notifications/types")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/notifications/types"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/notifications/types"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/types")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/notifications/types') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/notifications/types";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/notifications/types
http GET {{baseUrl}}/notifications/types
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/notifications/types
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications/types")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Send test notification to current user via Email and SMS
{{baseUrl}}/notifications/test
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/notifications/test");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/notifications/test")
require "http/client"

url = "{{baseUrl}}/notifications/test"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/notifications/test"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/notifications/test");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/notifications/test"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/notifications/test HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/notifications/test")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/test"))
    .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}}/notifications/test")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/notifications/test")
  .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}}/notifications/test');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/notifications/test'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/notifications/test';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/test',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications/test")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications/test',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/notifications/test'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/notifications/test');

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}}/notifications/test'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/notifications/test';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/test"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications/test" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/notifications/test",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/notifications/test');

echo $response->getBody();
setUrl('{{baseUrl}}/notifications/test');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/notifications/test');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/test' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/test' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/notifications/test")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/notifications/test"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/notifications/test"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/test")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/notifications/test') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/notifications/test";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/notifications/test
http POST {{baseUrl}}/notifications/test
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/notifications/test
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications/test")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update a Notification
{{baseUrl}}/notifications/:id
QUERY PARAMS
id
BODY json
{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/notifications/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/notifications/:id" {:content-type :json
                                                             :form-params {:always false
                                                                           :attributes {}
                                                                           :calendarId 0
                                                                           :id 0
                                                                           :mail false
                                                                           :sms false
                                                                           :type ""
                                                                           :web false}})
require "http/client"

url = "{{baseUrl}}/notifications/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/notifications/:id"),
    Content = new StringContent("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/notifications/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/notifications/:id"

	payload := strings.NewReader("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/notifications/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/notifications/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/notifications/:id")
  .header("content-type", "application/json")
  .body("{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
  .asString();
const data = JSON.stringify({
  always: false,
  attributes: {},
  calendarId: 0,
  id: 0,
  mail: false,
  sms: false,
  type: '',
  web: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/notifications/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'content-type': 'application/json'},
  data: {
    always: false,
    attributes: {},
    calendarId: 0,
    id: 0,
    mail: false,
    sms: false,
    type: '',
    web: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/notifications/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"always":false,"attributes":{},"calendarId":0,"id":0,"mail":false,"sms":false,"type":"","web":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "always": false,\n  "attributes": {},\n  "calendarId": 0,\n  "id": 0,\n  "mail": false,\n  "sms": false,\n  "type": "",\n  "web": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  always: false,
  attributes: {},
  calendarId: 0,
  id: 0,
  mail: false,
  sms: false,
  type: '',
  web: false
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'content-type': 'application/json'},
  body: {
    always: false,
    attributes: {},
    calendarId: 0,
    id: 0,
    mail: false,
    sms: false,
    type: '',
    web: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/notifications/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  always: false,
  attributes: {},
  calendarId: 0,
  id: 0,
  mail: false,
  sms: false,
  type: '',
  web: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'content-type': 'application/json'},
  data: {
    always: false,
    attributes: {},
    calendarId: 0,
    id: 0,
    mail: false,
    sms: false,
    type: '',
    web: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/notifications/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"always":false,"attributes":{},"calendarId":0,"id":0,"mail":false,"sms":false,"type":"","web":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"always": @NO,
                              @"attributes": @{  },
                              @"calendarId": @0,
                              @"id": @0,
                              @"mail": @NO,
                              @"sms": @NO,
                              @"type": @"",
                              @"web": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/notifications/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'always' => null,
    'attributes' => [
        
    ],
    'calendarId' => 0,
    'id' => 0,
    'mail' => null,
    'sms' => null,
    'type' => '',
    'web' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/notifications/:id', [
  'body' => '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/notifications/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'always' => null,
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'id' => 0,
  'mail' => null,
  'sms' => null,
  'type' => '',
  'web' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'always' => null,
  'attributes' => [
    
  ],
  'calendarId' => 0,
  'id' => 0,
  'mail' => null,
  'sms' => null,
  'type' => '',
  'web' => null
]));
$request->setRequestUrl('{{baseUrl}}/notifications/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/notifications/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/notifications/:id"

payload = {
    "always": False,
    "attributes": {},
    "calendarId": 0,
    "id": 0,
    "mail": False,
    "sms": False,
    "type": "",
    "web": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/notifications/:id"

payload <- "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/notifications/:id') do |req|
  req.body = "{\n  \"always\": false,\n  \"attributes\": {},\n  \"calendarId\": 0,\n  \"id\": 0,\n  \"mail\": false,\n  \"sms\": false,\n  \"type\": \"\",\n  \"web\": false\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/notifications/:id";

    let payload = json!({
        "always": false,
        "attributes": json!({}),
        "calendarId": 0,
        "id": 0,
        "mail": false,
        "sms": false,
        "type": "",
        "web": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/notifications/:id \
  --header 'content-type: application/json' \
  --data '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}'
echo '{
  "always": false,
  "attributes": {},
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
}' |  \
  http PUT {{baseUrl}}/notifications/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "always": false,\n  "attributes": {},\n  "calendarId": 0,\n  "id": 0,\n  "mail": false,\n  "sms": false,\n  "type": "",\n  "web": false\n}' \
  --output-document \
  - {{baseUrl}}/notifications/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "always": false,
  "attributes": [],
  "calendarId": 0,
  "id": 0,
  "mail": false,
  "sms": false,
  "type": "",
  "web": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/permissions" {:content-type :json
                                                        :form-params {:attributeId 0
                                                                      :calendarId 0
                                                                      :deviceId 0
                                                                      :driverId 0
                                                                      :geofenceId 0
                                                                      :groupId 0
                                                                      :managedUserId 0
                                                                      :notificationId 0
                                                                      :userId 0}})
require "http/client"

url = "{{baseUrl}}/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/permissions"),
    Content = new StringContent("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/permissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/permissions"

	payload := strings.NewReader("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 170

{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/permissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/permissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
  .asString();
const data = JSON.stringify({
  attributeId: 0,
  calendarId: 0,
  deviceId: 0,
  driverId: 0,
  geofenceId: 0,
  groupId: 0,
  managedUserId: 0,
  notificationId: 0,
  userId: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/permissions',
  headers: {'content-type': 'application/json'},
  data: {
    attributeId: 0,
    calendarId: 0,
    deviceId: 0,
    driverId: 0,
    geofenceId: 0,
    groupId: 0,
    managedUserId: 0,
    notificationId: 0,
    userId: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributeId":0,"calendarId":0,"deviceId":0,"driverId":0,"geofenceId":0,"groupId":0,"managedUserId":0,"notificationId":0,"userId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/permissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributeId": 0,\n  "calendarId": 0,\n  "deviceId": 0,\n  "driverId": 0,\n  "geofenceId": 0,\n  "groupId": 0,\n  "managedUserId": 0,\n  "notificationId": 0,\n  "userId": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/permissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/permissions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  attributeId: 0,
  calendarId: 0,
  deviceId: 0,
  driverId: 0,
  geofenceId: 0,
  groupId: 0,
  managedUserId: 0,
  notificationId: 0,
  userId: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/permissions',
  headers: {'content-type': 'application/json'},
  body: {
    attributeId: 0,
    calendarId: 0,
    deviceId: 0,
    driverId: 0,
    geofenceId: 0,
    groupId: 0,
    managedUserId: 0,
    notificationId: 0,
    userId: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributeId: 0,
  calendarId: 0,
  deviceId: 0,
  driverId: 0,
  geofenceId: 0,
  groupId: 0,
  managedUserId: 0,
  notificationId: 0,
  userId: 0
});

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}}/permissions',
  headers: {'content-type': 'application/json'},
  data: {
    attributeId: 0,
    calendarId: 0,
    deviceId: 0,
    driverId: 0,
    geofenceId: 0,
    groupId: 0,
    managedUserId: 0,
    notificationId: 0,
    userId: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/permissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"attributeId":0,"calendarId":0,"deviceId":0,"driverId":0,"geofenceId":0,"groupId":0,"managedUserId":0,"notificationId":0,"userId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributeId": @0,
                              @"calendarId": @0,
                              @"deviceId": @0,
                              @"driverId": @0,
                              @"geofenceId": @0,
                              @"groupId": @0,
                              @"managedUserId": @0,
                              @"notificationId": @0,
                              @"userId": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'attributeId' => 0,
    'calendarId' => 0,
    'deviceId' => 0,
    'driverId' => 0,
    'geofenceId' => 0,
    'groupId' => 0,
    'managedUserId' => 0,
    'notificationId' => 0,
    'userId' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/permissions', [
  'body' => '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/permissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributeId' => 0,
  'calendarId' => 0,
  'deviceId' => 0,
  'driverId' => 0,
  'geofenceId' => 0,
  'groupId' => 0,
  'managedUserId' => 0,
  'notificationId' => 0,
  'userId' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributeId' => 0,
  'calendarId' => 0,
  'deviceId' => 0,
  'driverId' => 0,
  'geofenceId' => 0,
  'groupId' => 0,
  'managedUserId' => 0,
  'notificationId' => 0,
  'userId' => 0
]));
$request->setRequestUrl('{{baseUrl}}/permissions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/permissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/permissions"

payload = {
    "attributeId": 0,
    "calendarId": 0,
    "deviceId": 0,
    "driverId": 0,
    "geofenceId": 0,
    "groupId": 0,
    "managedUserId": 0,
    "notificationId": 0,
    "userId": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/permissions"

payload <- "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/permissions') do |req|
  req.body = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/permissions";

    let payload = json!({
        "attributeId": 0,
        "calendarId": 0,
        "deviceId": 0,
        "driverId": 0,
        "geofenceId": 0,
        "groupId": 0,
        "managedUserId": 0,
        "notificationId": 0,
        "userId": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/permissions \
  --header 'content-type: application/json' \
  --data '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}'
echo '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}' |  \
  http POST {{baseUrl}}/permissions \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributeId": 0,\n  "calendarId": 0,\n  "deviceId": 0,\n  "driverId": 0,\n  "geofenceId": 0,\n  "groupId": 0,\n  "managedUserId": 0,\n  "notificationId": 0,\n  "userId": 0\n}' \
  --output-document \
  - {{baseUrl}}/permissions
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/permissions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/permissions" {:content-type :json
                                                          :form-params {:attributeId 0
                                                                        :calendarId 0
                                                                        :deviceId 0
                                                                        :driverId 0
                                                                        :geofenceId 0
                                                                        :groupId 0
                                                                        :managedUserId 0
                                                                        :notificationId 0
                                                                        :userId 0}})
require "http/client"

url = "{{baseUrl}}/permissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/permissions"),
    Content = new StringContent("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/permissions");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/permissions"

	payload := strings.NewReader("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/permissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 170

{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/permissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/permissions"))
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/permissions")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/permissions")
  .header("content-type", "application/json")
  .body("{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
  .asString();
const data = JSON.stringify({
  attributeId: 0,
  calendarId: 0,
  deviceId: 0,
  driverId: 0,
  geofenceId: 0,
  groupId: 0,
  managedUserId: 0,
  notificationId: 0,
  userId: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/permissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/permissions',
  headers: {'content-type': 'application/json'},
  data: {
    attributeId: 0,
    calendarId: 0,
    deviceId: 0,
    driverId: 0,
    geofenceId: 0,
    groupId: 0,
    managedUserId: 0,
    notificationId: 0,
    userId: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/permissions';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '{"attributeId":0,"calendarId":0,"deviceId":0,"driverId":0,"geofenceId":0,"groupId":0,"managedUserId":0,"notificationId":0,"userId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/permissions',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributeId": 0,\n  "calendarId": 0,\n  "deviceId": 0,\n  "driverId": 0,\n  "geofenceId": 0,\n  "groupId": 0,\n  "managedUserId": 0,\n  "notificationId": 0,\n  "userId": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/permissions")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/permissions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  attributeId: 0,
  calendarId: 0,
  deviceId: 0,
  driverId: 0,
  geofenceId: 0,
  groupId: 0,
  managedUserId: 0,
  notificationId: 0,
  userId: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/permissions',
  headers: {'content-type': 'application/json'},
  body: {
    attributeId: 0,
    calendarId: 0,
    deviceId: 0,
    driverId: 0,
    geofenceId: 0,
    groupId: 0,
    managedUserId: 0,
    notificationId: 0,
    userId: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/permissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributeId: 0,
  calendarId: 0,
  deviceId: 0,
  driverId: 0,
  geofenceId: 0,
  groupId: 0,
  managedUserId: 0,
  notificationId: 0,
  userId: 0
});

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}}/permissions',
  headers: {'content-type': 'application/json'},
  data: {
    attributeId: 0,
    calendarId: 0,
    deviceId: 0,
    driverId: 0,
    geofenceId: 0,
    groupId: 0,
    managedUserId: 0,
    notificationId: 0,
    userId: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/permissions';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '{"attributeId":0,"calendarId":0,"deviceId":0,"driverId":0,"geofenceId":0,"groupId":0,"managedUserId":0,"notificationId":0,"userId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributeId": @0,
                              @"calendarId": @0,
                              @"deviceId": @0,
                              @"driverId": @0,
                              @"geofenceId": @0,
                              @"groupId": @0,
                              @"managedUserId": @0,
                              @"notificationId": @0,
                              @"userId": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/permissions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/permissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/permissions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    'attributeId' => 0,
    'calendarId' => 0,
    'deviceId' => 0,
    'driverId' => 0,
    'geofenceId' => 0,
    'groupId' => 0,
    'managedUserId' => 0,
    'notificationId' => 0,
    'userId' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/permissions', [
  'body' => '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/permissions');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributeId' => 0,
  'calendarId' => 0,
  'deviceId' => 0,
  'driverId' => 0,
  'geofenceId' => 0,
  'groupId' => 0,
  'managedUserId' => 0,
  'notificationId' => 0,
  'userId' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributeId' => 0,
  'calendarId' => 0,
  'deviceId' => 0,
  'driverId' => 0,
  'geofenceId' => 0,
  'groupId' => 0,
  'managedUserId' => 0,
  'notificationId' => 0,
  'userId' => 0
]));
$request->setRequestUrl('{{baseUrl}}/permissions');
$request->setRequestMethod('DELETE');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/permissions' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/permissions' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("DELETE", "/baseUrl/permissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/permissions"

payload = {
    "attributeId": 0,
    "calendarId": 0,
    "deviceId": 0,
    "driverId": 0,
    "geofenceId": 0,
    "groupId": 0,
    "managedUserId": 0,
    "notificationId": 0,
    "userId": 0
}
headers = {"content-type": "application/json"}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/permissions"

payload <- "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

encode <- "json"

response <- VERB("DELETE", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.delete('/baseUrl/permissions') do |req|
  req.body = "{\n  \"attributeId\": 0,\n  \"calendarId\": 0,\n  \"deviceId\": 0,\n  \"driverId\": 0,\n  \"geofenceId\": 0,\n  \"groupId\": 0,\n  \"managedUserId\": 0,\n  \"notificationId\": 0,\n  \"userId\": 0\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/permissions";

    let payload = json!({
        "attributeId": 0,
        "calendarId": 0,
        "deviceId": 0,
        "driverId": 0,
        "geofenceId": 0,
        "groupId": 0,
        "managedUserId": 0,
        "notificationId": 0,
        "userId": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/permissions \
  --header 'content-type: application/json' \
  --data '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}'
echo '{
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
}' |  \
  http DELETE {{baseUrl}}/permissions \
  content-type:application/json
wget --quiet \
  --method DELETE \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributeId": 0,\n  "calendarId": 0,\n  "deviceId": 0,\n  "driverId": 0,\n  "geofenceId": 0,\n  "groupId": 0,\n  "managedUserId": 0,\n  "notificationId": 0,\n  "userId": 0\n}' \
  --output-document \
  - {{baseUrl}}/permissions
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributeId": 0,
  "calendarId": 0,
  "deviceId": 0,
  "driverId": 0,
  "geofenceId": 0,
  "groupId": 0,
  "managedUserId": 0,
  "notificationId": 0,
  "userId": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetches a list of Positions
{{baseUrl}}/positions
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/positions");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/positions")
require "http/client"

url = "{{baseUrl}}/positions"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/positions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/positions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/positions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/positions HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/positions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/positions"))
    .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}}/positions")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/positions")
  .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}}/positions');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/positions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/positions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/positions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/positions")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/positions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/positions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/positions');

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}}/positions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/positions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/positions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/positions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/positions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/positions');

echo $response->getBody();
setUrl('{{baseUrl}}/positions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/positions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/positions' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/positions' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/positions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/positions"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/positions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/positions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/positions') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/positions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/positions
http GET {{baseUrl}}/positions
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/positions
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/positions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Events within the time period for the Devices or Groups
{{baseUrl}}/reports/events
QUERY PARAMS
from
to
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reports/events?from=&to=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/reports/events" {:query-params {:from ""
                                                                         :to ""}})
require "http/client"

url = "{{baseUrl}}/reports/events?from=&to="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/reports/events?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/reports/events?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/reports/events?from=&to="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/reports/events?from=&to= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/reports/events?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/reports/events?from=&to="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/reports/events?from=&to=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/reports/events?from=&to=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/reports/events?from=&to=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/events',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/reports/events?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/reports/events?from=&to=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/reports/events?from=&to=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/reports/events?from=&to=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/events',
  qs: {from: '', to: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/reports/events');

req.query({
  from: '',
  to: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/events',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/reports/events?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reports/events?from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/reports/events?from=&to=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/reports/events?from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/reports/events?from=&to=');

echo $response->getBody();
setUrl('{{baseUrl}}/reports/events');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/reports/events');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reports/events?from=&to=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reports/events?from=&to=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/reports/events?from=&to=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/reports/events"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/reports/events"

queryString <- list(
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/reports/events?from=&to=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/reports/events') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/reports/events";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/reports/events?from=&to='
http GET '{{baseUrl}}/reports/events?from=&to='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/reports/events?from=&to='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reports/events?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Positions within the time period for the Devices or Groups
{{baseUrl}}/reports/route
QUERY PARAMS
from
to
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reports/route?from=&to=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/reports/route" {:query-params {:from ""
                                                                        :to ""}})
require "http/client"

url = "{{baseUrl}}/reports/route?from=&to="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/reports/route?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/reports/route?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/reports/route?from=&to="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/reports/route?from=&to= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/reports/route?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/reports/route?from=&to="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/reports/route?from=&to=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/reports/route?from=&to=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/reports/route?from=&to=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/route',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/reports/route?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/reports/route?from=&to=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/reports/route?from=&to=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/reports/route?from=&to=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/route',
  qs: {from: '', to: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/reports/route');

req.query({
  from: '',
  to: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/route',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/reports/route?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reports/route?from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/reports/route?from=&to=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/reports/route?from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/reports/route?from=&to=');

echo $response->getBody();
setUrl('{{baseUrl}}/reports/route');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/reports/route');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reports/route?from=&to=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reports/route?from=&to=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/reports/route?from=&to=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/reports/route"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/reports/route"

queryString <- list(
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/reports/route?from=&to=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/reports/route') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/reports/route";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/reports/route?from=&to='
http GET '{{baseUrl}}/reports/route?from=&to='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/reports/route?from=&to='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reports/route?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of ReportStops within the time period for the Devices or Groups
{{baseUrl}}/reports/stops
QUERY PARAMS
from
to
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reports/stops?from=&to=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/reports/stops" {:query-params {:from ""
                                                                        :to ""}})
require "http/client"

url = "{{baseUrl}}/reports/stops?from=&to="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/reports/stops?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/reports/stops?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/reports/stops?from=&to="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/reports/stops?from=&to= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/reports/stops?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/reports/stops?from=&to="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/reports/stops?from=&to=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/reports/stops?from=&to=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/reports/stops?from=&to=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/stops',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/reports/stops?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/reports/stops?from=&to=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/reports/stops?from=&to=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/reports/stops?from=&to=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/stops',
  qs: {from: '', to: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/reports/stops');

req.query({
  from: '',
  to: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/stops',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/reports/stops?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reports/stops?from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/reports/stops?from=&to=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/reports/stops?from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/reports/stops?from=&to=');

echo $response->getBody();
setUrl('{{baseUrl}}/reports/stops');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/reports/stops');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reports/stops?from=&to=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reports/stops?from=&to=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/reports/stops?from=&to=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/reports/stops"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/reports/stops"

queryString <- list(
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/reports/stops?from=&to=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/reports/stops') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/reports/stops";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/reports/stops?from=&to='
http GET '{{baseUrl}}/reports/stops?from=&to='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/reports/stops?from=&to='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reports/stops?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of ReportSummary within the time period for the Devices or Groups
{{baseUrl}}/reports/summary
QUERY PARAMS
from
to
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reports/summary?from=&to=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/reports/summary" {:query-params {:from ""
                                                                          :to ""}})
require "http/client"

url = "{{baseUrl}}/reports/summary?from=&to="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/reports/summary?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/reports/summary?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/reports/summary?from=&to="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/reports/summary?from=&to= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/reports/summary?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/reports/summary?from=&to="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/reports/summary?from=&to=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/reports/summary?from=&to=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/reports/summary?from=&to=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/summary',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/reports/summary?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/reports/summary?from=&to=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/reports/summary?from=&to=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/reports/summary?from=&to=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/summary',
  qs: {from: '', to: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/reports/summary');

req.query({
  from: '',
  to: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/summary',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/reports/summary?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reports/summary?from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/reports/summary?from=&to=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/reports/summary?from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/reports/summary?from=&to=');

echo $response->getBody();
setUrl('{{baseUrl}}/reports/summary');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/reports/summary');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reports/summary?from=&to=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reports/summary?from=&to=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/reports/summary?from=&to=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/reports/summary"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/reports/summary"

queryString <- list(
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/reports/summary?from=&to=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/reports/summary') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/reports/summary";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/reports/summary?from=&to='
http GET '{{baseUrl}}/reports/summary?from=&to='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/reports/summary?from=&to='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reports/summary?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of ReportTrips within the time period for the Devices or Groups
{{baseUrl}}/reports/trips
QUERY PARAMS
from
to
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reports/trips?from=&to=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/reports/trips" {:query-params {:from ""
                                                                        :to ""}})
require "http/client"

url = "{{baseUrl}}/reports/trips?from=&to="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/reports/trips?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/reports/trips?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/reports/trips?from=&to="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/reports/trips?from=&to= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/reports/trips?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/reports/trips?from=&to="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/reports/trips?from=&to=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/reports/trips?from=&to=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/reports/trips?from=&to=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/trips',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/reports/trips?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/reports/trips?from=&to=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/reports/trips?from=&to=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/reports/trips?from=&to=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/trips',
  qs: {from: '', to: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/reports/trips');

req.query({
  from: '',
  to: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/reports/trips',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/reports/trips?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reports/trips?from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/reports/trips?from=&to=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/reports/trips?from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/reports/trips?from=&to=');

echo $response->getBody();
setUrl('{{baseUrl}}/reports/trips');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/reports/trips');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reports/trips?from=&to=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reports/trips?from=&to=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/reports/trips?from=&to=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/reports/trips"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/reports/trips"

queryString <- list(
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/reports/trips?from=&to=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/reports/trips') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/reports/trips";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/reports/trips?from=&to='
http GET '{{baseUrl}}/reports/trips?from=&to='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/reports/trips?from=&to='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reports/trips?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch Server information
{{baseUrl}}/server
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/server");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/server")
require "http/client"

url = "{{baseUrl}}/server"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/server"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/server");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/server"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/server HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/server")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/server"))
    .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}}/server")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/server")
  .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}}/server');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/server'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/server';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/server',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/server")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/server',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/server'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/server');

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}}/server'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/server';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/server"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/server" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/server",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/server');

echo $response->getBody();
setUrl('{{baseUrl}}/server');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/server');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/server' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/server' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/server")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/server"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/server"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/server")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/server') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/server";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/server
http GET {{baseUrl}}/server
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/server
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/server")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update Server information
{{baseUrl}}/server
BODY json
{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/server");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/server" {:content-type :json
                                                  :form-params {:attributes {}
                                                                :bingKey ""
                                                                :coordinateFormat ""
                                                                :deviceReadonly false
                                                                :forceSettings false
                                                                :id 0
                                                                :latitude ""
                                                                :limitCommands false
                                                                :longitude ""
                                                                :map ""
                                                                :mapUrl ""
                                                                :poiLayer ""
                                                                :readonly false
                                                                :registration false
                                                                :twelveHourFormat false
                                                                :version ""
                                                                :zoom 0}})
require "http/client"

url = "{{baseUrl}}/server"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/server"),
    Content = new StringContent("{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/server");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/server"

	payload := strings.NewReader("{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/server HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 344

{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/server")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/server"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/server")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/server")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}")
  .asString();
const data = JSON.stringify({
  attributes: {},
  bingKey: '',
  coordinateFormat: '',
  deviceReadonly: false,
  forceSettings: false,
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  mapUrl: '',
  poiLayer: '',
  readonly: false,
  registration: false,
  twelveHourFormat: false,
  version: '',
  zoom: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/server');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/server',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    bingKey: '',
    coordinateFormat: '',
    deviceReadonly: false,
    forceSettings: false,
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    mapUrl: '',
    poiLayer: '',
    readonly: false,
    registration: false,
    twelveHourFormat: false,
    version: '',
    zoom: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/server';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"bingKey":"","coordinateFormat":"","deviceReadonly":false,"forceSettings":false,"id":0,"latitude":"","limitCommands":false,"longitude":"","map":"","mapUrl":"","poiLayer":"","readonly":false,"registration":false,"twelveHourFormat":false,"version":"","zoom":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/server',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {},\n  "bingKey": "",\n  "coordinateFormat": "",\n  "deviceReadonly": false,\n  "forceSettings": false,\n  "id": 0,\n  "latitude": "",\n  "limitCommands": false,\n  "longitude": "",\n  "map": "",\n  "mapUrl": "",\n  "poiLayer": "",\n  "readonly": false,\n  "registration": false,\n  "twelveHourFormat": false,\n  "version": "",\n  "zoom": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/server")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/server',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  attributes: {},
  bingKey: '',
  coordinateFormat: '',
  deviceReadonly: false,
  forceSettings: false,
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  mapUrl: '',
  poiLayer: '',
  readonly: false,
  registration: false,
  twelveHourFormat: false,
  version: '',
  zoom: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/server',
  headers: {'content-type': 'application/json'},
  body: {
    attributes: {},
    bingKey: '',
    coordinateFormat: '',
    deviceReadonly: false,
    forceSettings: false,
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    mapUrl: '',
    poiLayer: '',
    readonly: false,
    registration: false,
    twelveHourFormat: false,
    version: '',
    zoom: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/server');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {},
  bingKey: '',
  coordinateFormat: '',
  deviceReadonly: false,
  forceSettings: false,
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  mapUrl: '',
  poiLayer: '',
  readonly: false,
  registration: false,
  twelveHourFormat: false,
  version: '',
  zoom: 0
});

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}}/server',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {},
    bingKey: '',
    coordinateFormat: '',
    deviceReadonly: false,
    forceSettings: false,
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    mapUrl: '',
    poiLayer: '',
    readonly: false,
    registration: false,
    twelveHourFormat: false,
    version: '',
    zoom: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/server';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{},"bingKey":"","coordinateFormat":"","deviceReadonly":false,"forceSettings":false,"id":0,"latitude":"","limitCommands":false,"longitude":"","map":"","mapUrl":"","poiLayer":"","readonly":false,"registration":false,"twelveHourFormat":false,"version":"","zoom":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"attributes": @{  },
                              @"bingKey": @"",
                              @"coordinateFormat": @"",
                              @"deviceReadonly": @NO,
                              @"forceSettings": @NO,
                              @"id": @0,
                              @"latitude": @"",
                              @"limitCommands": @NO,
                              @"longitude": @"",
                              @"map": @"",
                              @"mapUrl": @"",
                              @"poiLayer": @"",
                              @"readonly": @NO,
                              @"registration": @NO,
                              @"twelveHourFormat": @NO,
                              @"version": @"",
                              @"zoom": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/server"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/server" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/server",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'attributes' => [
        
    ],
    'bingKey' => '',
    'coordinateFormat' => '',
    'deviceReadonly' => null,
    'forceSettings' => null,
    'id' => 0,
    'latitude' => '',
    'limitCommands' => null,
    'longitude' => '',
    'map' => '',
    'mapUrl' => '',
    'poiLayer' => '',
    'readonly' => null,
    'registration' => null,
    'twelveHourFormat' => null,
    'version' => '',
    'zoom' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/server', [
  'body' => '{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/server');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    
  ],
  'bingKey' => '',
  'coordinateFormat' => '',
  'deviceReadonly' => null,
  'forceSettings' => null,
  'id' => 0,
  'latitude' => '',
  'limitCommands' => null,
  'longitude' => '',
  'map' => '',
  'mapUrl' => '',
  'poiLayer' => '',
  'readonly' => null,
  'registration' => null,
  'twelveHourFormat' => null,
  'version' => '',
  'zoom' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'attributes' => [
    
  ],
  'bingKey' => '',
  'coordinateFormat' => '',
  'deviceReadonly' => null,
  'forceSettings' => null,
  'id' => 0,
  'latitude' => '',
  'limitCommands' => null,
  'longitude' => '',
  'map' => '',
  'mapUrl' => '',
  'poiLayer' => '',
  'readonly' => null,
  'registration' => null,
  'twelveHourFormat' => null,
  'version' => '',
  'zoom' => 0
]));
$request->setRequestUrl('{{baseUrl}}/server');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/server' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/server' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/server", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/server"

payload = {
    "attributes": {},
    "bingKey": "",
    "coordinateFormat": "",
    "deviceReadonly": False,
    "forceSettings": False,
    "id": 0,
    "latitude": "",
    "limitCommands": False,
    "longitude": "",
    "map": "",
    "mapUrl": "",
    "poiLayer": "",
    "readonly": False,
    "registration": False,
    "twelveHourFormat": False,
    "version": "",
    "zoom": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/server"

payload <- "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/server")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/server') do |req|
  req.body = "{\n  \"attributes\": {},\n  \"bingKey\": \"\",\n  \"coordinateFormat\": \"\",\n  \"deviceReadonly\": false,\n  \"forceSettings\": false,\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"mapUrl\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"registration\": false,\n  \"twelveHourFormat\": false,\n  \"version\": \"\",\n  \"zoom\": 0\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/server";

    let payload = json!({
        "attributes": json!({}),
        "bingKey": "",
        "coordinateFormat": "",
        "deviceReadonly": false,
        "forceSettings": false,
        "id": 0,
        "latitude": "",
        "limitCommands": false,
        "longitude": "",
        "map": "",
        "mapUrl": "",
        "poiLayer": "",
        "readonly": false,
        "registration": false,
        "twelveHourFormat": false,
        "version": "",
        "zoom": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/server \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}'
echo '{
  "attributes": {},
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
}' |  \
  http PUT {{baseUrl}}/server \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {},\n  "bingKey": "",\n  "coordinateFormat": "",\n  "deviceReadonly": false,\n  "forceSettings": false,\n  "id": 0,\n  "latitude": "",\n  "limitCommands": false,\n  "longitude": "",\n  "map": "",\n  "mapUrl": "",\n  "poiLayer": "",\n  "readonly": false,\n  "registration": false,\n  "twelveHourFormat": false,\n  "version": "",\n  "zoom": 0\n}' \
  --output-document \
  - {{baseUrl}}/server
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [],
  "bingKey": "",
  "coordinateFormat": "",
  "deviceReadonly": false,
  "forceSettings": false,
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "mapUrl": "",
  "poiLayer": "",
  "readonly": false,
  "registration": false,
  "twelveHourFormat": false,
  "version": "",
  "zoom": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/server")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Close the Session
{{baseUrl}}/session
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/session");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/session")
require "http/client"

url = "{{baseUrl}}/session"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/session"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/session");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/session"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/session HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/session")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/session"))
    .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}}/session")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/session")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/session');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/session';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/session',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/session")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/session',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/session'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/session');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/session';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/session"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/session" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/session",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/session');

echo $response->getBody();
setUrl('{{baseUrl}}/session');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/session');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/session' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/session' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/session")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/session"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/session"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/session")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/session') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/session";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/session
http DELETE {{baseUrl}}/session
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/session
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/session")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a new Session
{{baseUrl}}/session
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/session");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/session")
require "http/client"

url = "{{baseUrl}}/session"

response = HTTP::Client.post url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/session"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/session");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/session"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/session HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/session")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/session"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/session")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/session")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/session');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/session';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/session',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/session")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/session',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/session'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/session');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/session';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/session"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/session" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/session",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/session');

echo $response->getBody();
setUrl('{{baseUrl}}/session');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/session');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/session' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/session' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/session")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/session"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/session"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/session")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/session') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/session";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/session
http POST {{baseUrl}}/session
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/session
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/session")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch Session information
{{baseUrl}}/session
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/session");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/session")
require "http/client"

url = "{{baseUrl}}/session"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/session"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/session");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/session"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/session HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/session")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/session"))
    .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}}/session")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/session")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/session');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/session';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/session',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/session")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/session',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/session'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/session');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/session';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/session"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/session" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/session",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/session');

echo $response->getBody();
setUrl('{{baseUrl}}/session');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/session');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/session' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/session' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/session")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/session"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/session"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/session")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/session') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/session";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/session
http GET {{baseUrl}}/session
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/session
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/session")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch server Statistics
{{baseUrl}}/statistics
QUERY PARAMS
from
to
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/statistics?from=&to=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/statistics" {:query-params {:from ""
                                                                     :to ""}})
require "http/client"

url = "{{baseUrl}}/statistics?from=&to="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/statistics?from=&to="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/statistics?from=&to=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/statistics?from=&to="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/statistics?from=&to= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/statistics?from=&to=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/statistics?from=&to="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/statistics?from=&to=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/statistics?from=&to=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/statistics?from=&to=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/statistics',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/statistics?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/statistics?from=&to=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/statistics?from=&to=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/statistics?from=&to=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/statistics',
  qs: {from: '', to: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/statistics');

req.query({
  from: '',
  to: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/statistics',
  params: {from: '', to: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/statistics?from=&to=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/statistics?from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/statistics?from=&to=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/statistics?from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/statistics?from=&to=');

echo $response->getBody();
setUrl('{{baseUrl}}/statistics');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'from' => '',
  'to' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/statistics');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'from' => '',
  'to' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/statistics?from=&to=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/statistics?from=&to=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/statistics?from=&to=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/statistics"

querystring = {"from":"","to":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/statistics"

queryString <- list(
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/statistics?from=&to=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/statistics') do |req|
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/statistics";

    let querystring = [
        ("from", ""),
        ("to", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/statistics?from=&to='
http GET '{{baseUrl}}/statistics?from=&to='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/statistics?from=&to='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/statistics?from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a User
{{baseUrl}}/users
BODY json
{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/users" {:content-type :json
                                                  :form-params {:administrator false
                                                                :attributes {}
                                                                :coordinateFormat ""
                                                                :deviceLimit 0
                                                                :deviceReadonly false
                                                                :disabled false
                                                                :email ""
                                                                :expirationTime ""
                                                                :id 0
                                                                :latitude ""
                                                                :limitCommands false
                                                                :longitude ""
                                                                :map ""
                                                                :name ""
                                                                :password ""
                                                                :phone ""
                                                                :poiLayer ""
                                                                :readonly false
                                                                :twelveHourFormat false
                                                                :userLimit 0
                                                                :zoom 0}})
require "http/client"

url = "{{baseUrl}}/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/users"),
    Content = new StringContent("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users"

	payload := strings.NewReader("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 414

{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/users")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/users")
  .header("content-type", "application/json")
  .body("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
  .asString();
const data = JSON.stringify({
  administrator: false,
  attributes: {},
  coordinateFormat: '',
  deviceLimit: 0,
  deviceReadonly: false,
  disabled: false,
  email: '',
  expirationTime: '',
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  name: '',
  password: '',
  phone: '',
  poiLayer: '',
  readonly: false,
  twelveHourFormat: false,
  userLimit: 0,
  zoom: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/users',
  headers: {'content-type': 'application/json'},
  data: {
    administrator: false,
    attributes: {},
    coordinateFormat: '',
    deviceLimit: 0,
    deviceReadonly: false,
    disabled: false,
    email: '',
    expirationTime: '',
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    name: '',
    password: '',
    phone: '',
    poiLayer: '',
    readonly: false,
    twelveHourFormat: false,
    userLimit: 0,
    zoom: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"administrator":false,"attributes":{},"coordinateFormat":"","deviceLimit":0,"deviceReadonly":false,"disabled":false,"email":"","expirationTime":"","id":0,"latitude":"","limitCommands":false,"longitude":"","map":"","name":"","password":"","phone":"","poiLayer":"","readonly":false,"twelveHourFormat":false,"userLimit":0,"zoom":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "administrator": false,\n  "attributes": {},\n  "coordinateFormat": "",\n  "deviceLimit": 0,\n  "deviceReadonly": false,\n  "disabled": false,\n  "email": "",\n  "expirationTime": "",\n  "id": 0,\n  "latitude": "",\n  "limitCommands": false,\n  "longitude": "",\n  "map": "",\n  "name": "",\n  "password": "",\n  "phone": "",\n  "poiLayer": "",\n  "readonly": false,\n  "twelveHourFormat": false,\n  "userLimit": 0,\n  "zoom": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  administrator: false,
  attributes: {},
  coordinateFormat: '',
  deviceLimit: 0,
  deviceReadonly: false,
  disabled: false,
  email: '',
  expirationTime: '',
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  name: '',
  password: '',
  phone: '',
  poiLayer: '',
  readonly: false,
  twelveHourFormat: false,
  userLimit: 0,
  zoom: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/users',
  headers: {'content-type': 'application/json'},
  body: {
    administrator: false,
    attributes: {},
    coordinateFormat: '',
    deviceLimit: 0,
    deviceReadonly: false,
    disabled: false,
    email: '',
    expirationTime: '',
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    name: '',
    password: '',
    phone: '',
    poiLayer: '',
    readonly: false,
    twelveHourFormat: false,
    userLimit: 0,
    zoom: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  administrator: false,
  attributes: {},
  coordinateFormat: '',
  deviceLimit: 0,
  deviceReadonly: false,
  disabled: false,
  email: '',
  expirationTime: '',
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  name: '',
  password: '',
  phone: '',
  poiLayer: '',
  readonly: false,
  twelveHourFormat: false,
  userLimit: 0,
  zoom: 0
});

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}}/users',
  headers: {'content-type': 'application/json'},
  data: {
    administrator: false,
    attributes: {},
    coordinateFormat: '',
    deviceLimit: 0,
    deviceReadonly: false,
    disabled: false,
    email: '',
    expirationTime: '',
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    name: '',
    password: '',
    phone: '',
    poiLayer: '',
    readonly: false,
    twelveHourFormat: false,
    userLimit: 0,
    zoom: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"administrator":false,"attributes":{},"coordinateFormat":"","deviceLimit":0,"deviceReadonly":false,"disabled":false,"email":"","expirationTime":"","id":0,"latitude":"","limitCommands":false,"longitude":"","map":"","name":"","password":"","phone":"","poiLayer":"","readonly":false,"twelveHourFormat":false,"userLimit":0,"zoom":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"administrator": @NO,
                              @"attributes": @{  },
                              @"coordinateFormat": @"",
                              @"deviceLimit": @0,
                              @"deviceReadonly": @NO,
                              @"disabled": @NO,
                              @"email": @"",
                              @"expirationTime": @"",
                              @"id": @0,
                              @"latitude": @"",
                              @"limitCommands": @NO,
                              @"longitude": @"",
                              @"map": @"",
                              @"name": @"",
                              @"password": @"",
                              @"phone": @"",
                              @"poiLayer": @"",
                              @"readonly": @NO,
                              @"twelveHourFormat": @NO,
                              @"userLimit": @0,
                              @"zoom": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'administrator' => null,
    'attributes' => [
        
    ],
    'coordinateFormat' => '',
    'deviceLimit' => 0,
    'deviceReadonly' => null,
    'disabled' => null,
    'email' => '',
    'expirationTime' => '',
    'id' => 0,
    'latitude' => '',
    'limitCommands' => null,
    'longitude' => '',
    'map' => '',
    'name' => '',
    'password' => '',
    'phone' => '',
    'poiLayer' => '',
    'readonly' => null,
    'twelveHourFormat' => null,
    'userLimit' => 0,
    'zoom' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/users', [
  'body' => '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'administrator' => null,
  'attributes' => [
    
  ],
  'coordinateFormat' => '',
  'deviceLimit' => 0,
  'deviceReadonly' => null,
  'disabled' => null,
  'email' => '',
  'expirationTime' => '',
  'id' => 0,
  'latitude' => '',
  'limitCommands' => null,
  'longitude' => '',
  'map' => '',
  'name' => '',
  'password' => '',
  'phone' => '',
  'poiLayer' => '',
  'readonly' => null,
  'twelveHourFormat' => null,
  'userLimit' => 0,
  'zoom' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'administrator' => null,
  'attributes' => [
    
  ],
  'coordinateFormat' => '',
  'deviceLimit' => 0,
  'deviceReadonly' => null,
  'disabled' => null,
  'email' => '',
  'expirationTime' => '',
  'id' => 0,
  'latitude' => '',
  'limitCommands' => null,
  'longitude' => '',
  'map' => '',
  'name' => '',
  'password' => '',
  'phone' => '',
  'poiLayer' => '',
  'readonly' => null,
  'twelveHourFormat' => null,
  'userLimit' => 0,
  'zoom' => 0
]));
$request->setRequestUrl('{{baseUrl}}/users');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/users"

payload = {
    "administrator": False,
    "attributes": {},
    "coordinateFormat": "",
    "deviceLimit": 0,
    "deviceReadonly": False,
    "disabled": False,
    "email": "",
    "expirationTime": "",
    "id": 0,
    "latitude": "",
    "limitCommands": False,
    "longitude": "",
    "map": "",
    "name": "",
    "password": "",
    "phone": "",
    "poiLayer": "",
    "readonly": False,
    "twelveHourFormat": False,
    "userLimit": 0,
    "zoom": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/users"

payload <- "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/users') do |req|
  req.body = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users";

    let payload = json!({
        "administrator": false,
        "attributes": json!({}),
        "coordinateFormat": "",
        "deviceLimit": 0,
        "deviceReadonly": false,
        "disabled": false,
        "email": "",
        "expirationTime": "",
        "id": 0,
        "latitude": "",
        "limitCommands": false,
        "longitude": "",
        "map": "",
        "name": "",
        "password": "",
        "phone": "",
        "poiLayer": "",
        "readonly": false,
        "twelveHourFormat": false,
        "userLimit": 0,
        "zoom": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/users \
  --header 'content-type: application/json' \
  --data '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}'
echo '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}' |  \
  http POST {{baseUrl}}/users \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "administrator": false,\n  "attributes": {},\n  "coordinateFormat": "",\n  "deviceLimit": 0,\n  "deviceReadonly": false,\n  "disabled": false,\n  "email": "",\n  "expirationTime": "",\n  "id": 0,\n  "latitude": "",\n  "limitCommands": false,\n  "longitude": "",\n  "map": "",\n  "name": "",\n  "password": "",\n  "phone": "",\n  "poiLayer": "",\n  "readonly": false,\n  "twelveHourFormat": false,\n  "userLimit": 0,\n  "zoom": 0\n}' \
  --output-document \
  - {{baseUrl}}/users
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "administrator": false,
  "attributes": [],
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete a User
{{baseUrl}}/users/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/users/:id")
require "http/client"

url = "{{baseUrl}}/users/:id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/users/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/users/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/users/:id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/users/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/users/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/users/:id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/users/:id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/users/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/users/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/users/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/users/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/users/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/users/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/users/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/users/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/users/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/users/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/users/:id');

echo $response->getBody();
setUrl('{{baseUrl}}/users/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/users/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/users/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/users/:id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/users/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/users/:id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/users/:id
http DELETE {{baseUrl}}/users/:id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/users/:id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch a list of Users
{{baseUrl}}/users
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/users")
require "http/client"

url = "{{baseUrl}}/users"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/users HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users"))
    .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}}/users")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/users")
  .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}}/users');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/users")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/users'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/users');

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}}/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/users');

echo $response->getBody();
setUrl('{{baseUrl}}/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/users"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/users') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/users
http GET {{baseUrl}}/users
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/users
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
PUT Update a User
{{baseUrl}}/users/:id
QUERY PARAMS
id
BODY json
{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/users/:id" {:content-type :json
                                                     :form-params {:administrator false
                                                                   :attributes {}
                                                                   :coordinateFormat ""
                                                                   :deviceLimit 0
                                                                   :deviceReadonly false
                                                                   :disabled false
                                                                   :email ""
                                                                   :expirationTime ""
                                                                   :id 0
                                                                   :latitude ""
                                                                   :limitCommands false
                                                                   :longitude ""
                                                                   :map ""
                                                                   :name ""
                                                                   :password ""
                                                                   :phone ""
                                                                   :poiLayer ""
                                                                   :readonly false
                                                                   :twelveHourFormat false
                                                                   :userLimit 0
                                                                   :zoom 0}})
require "http/client"

url = "{{baseUrl}}/users/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/users/:id"),
    Content = new StringContent("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/users/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users/:id"

	payload := strings.NewReader("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/users/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 414

{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/users/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/users/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/users/:id")
  .header("content-type", "application/json")
  .body("{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
  .asString();
const data = JSON.stringify({
  administrator: false,
  attributes: {},
  coordinateFormat: '',
  deviceLimit: 0,
  deviceReadonly: false,
  disabled: false,
  email: '',
  expirationTime: '',
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  name: '',
  password: '',
  phone: '',
  poiLayer: '',
  readonly: false,
  twelveHourFormat: false,
  userLimit: 0,
  zoom: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/users/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:id',
  headers: {'content-type': 'application/json'},
  data: {
    administrator: false,
    attributes: {},
    coordinateFormat: '',
    deviceLimit: 0,
    deviceReadonly: false,
    disabled: false,
    email: '',
    expirationTime: '',
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    name: '',
    password: '',
    phone: '',
    poiLayer: '',
    readonly: false,
    twelveHourFormat: false,
    userLimit: 0,
    zoom: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/users/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"administrator":false,"attributes":{},"coordinateFormat":"","deviceLimit":0,"deviceReadonly":false,"disabled":false,"email":"","expirationTime":"","id":0,"latitude":"","limitCommands":false,"longitude":"","map":"","name":"","password":"","phone":"","poiLayer":"","readonly":false,"twelveHourFormat":false,"userLimit":0,"zoom":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/users/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "administrator": false,\n  "attributes": {},\n  "coordinateFormat": "",\n  "deviceLimit": 0,\n  "deviceReadonly": false,\n  "disabled": false,\n  "email": "",\n  "expirationTime": "",\n  "id": 0,\n  "latitude": "",\n  "limitCommands": false,\n  "longitude": "",\n  "map": "",\n  "name": "",\n  "password": "",\n  "phone": "",\n  "poiLayer": "",\n  "readonly": false,\n  "twelveHourFormat": false,\n  "userLimit": 0,\n  "zoom": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/users/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  administrator: false,
  attributes: {},
  coordinateFormat: '',
  deviceLimit: 0,
  deviceReadonly: false,
  disabled: false,
  email: '',
  expirationTime: '',
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  name: '',
  password: '',
  phone: '',
  poiLayer: '',
  readonly: false,
  twelveHourFormat: false,
  userLimit: 0,
  zoom: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:id',
  headers: {'content-type': 'application/json'},
  body: {
    administrator: false,
    attributes: {},
    coordinateFormat: '',
    deviceLimit: 0,
    deviceReadonly: false,
    disabled: false,
    email: '',
    expirationTime: '',
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    name: '',
    password: '',
    phone: '',
    poiLayer: '',
    readonly: false,
    twelveHourFormat: false,
    userLimit: 0,
    zoom: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/users/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  administrator: false,
  attributes: {},
  coordinateFormat: '',
  deviceLimit: 0,
  deviceReadonly: false,
  disabled: false,
  email: '',
  expirationTime: '',
  id: 0,
  latitude: '',
  limitCommands: false,
  longitude: '',
  map: '',
  name: '',
  password: '',
  phone: '',
  poiLayer: '',
  readonly: false,
  twelveHourFormat: false,
  userLimit: 0,
  zoom: 0
});

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}}/users/:id',
  headers: {'content-type': 'application/json'},
  data: {
    administrator: false,
    attributes: {},
    coordinateFormat: '',
    deviceLimit: 0,
    deviceReadonly: false,
    disabled: false,
    email: '',
    expirationTime: '',
    id: 0,
    latitude: '',
    limitCommands: false,
    longitude: '',
    map: '',
    name: '',
    password: '',
    phone: '',
    poiLayer: '',
    readonly: false,
    twelveHourFormat: false,
    userLimit: 0,
    zoom: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/users/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"administrator":false,"attributes":{},"coordinateFormat":"","deviceLimit":0,"deviceReadonly":false,"disabled":false,"email":"","expirationTime":"","id":0,"latitude":"","limitCommands":false,"longitude":"","map":"","name":"","password":"","phone":"","poiLayer":"","readonly":false,"twelveHourFormat":false,"userLimit":0,"zoom":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"administrator": @NO,
                              @"attributes": @{  },
                              @"coordinateFormat": @"",
                              @"deviceLimit": @0,
                              @"deviceReadonly": @NO,
                              @"disabled": @NO,
                              @"email": @"",
                              @"expirationTime": @"",
                              @"id": @0,
                              @"latitude": @"",
                              @"limitCommands": @NO,
                              @"longitude": @"",
                              @"map": @"",
                              @"name": @"",
                              @"password": @"",
                              @"phone": @"",
                              @"poiLayer": @"",
                              @"readonly": @NO,
                              @"twelveHourFormat": @NO,
                              @"userLimit": @0,
                              @"zoom": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/users/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/users/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'administrator' => null,
    'attributes' => [
        
    ],
    'coordinateFormat' => '',
    'deviceLimit' => 0,
    'deviceReadonly' => null,
    'disabled' => null,
    'email' => '',
    'expirationTime' => '',
    'id' => 0,
    'latitude' => '',
    'limitCommands' => null,
    'longitude' => '',
    'map' => '',
    'name' => '',
    'password' => '',
    'phone' => '',
    'poiLayer' => '',
    'readonly' => null,
    'twelveHourFormat' => null,
    'userLimit' => 0,
    'zoom' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/users/:id', [
  'body' => '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/users/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'administrator' => null,
  'attributes' => [
    
  ],
  'coordinateFormat' => '',
  'deviceLimit' => 0,
  'deviceReadonly' => null,
  'disabled' => null,
  'email' => '',
  'expirationTime' => '',
  'id' => 0,
  'latitude' => '',
  'limitCommands' => null,
  'longitude' => '',
  'map' => '',
  'name' => '',
  'password' => '',
  'phone' => '',
  'poiLayer' => '',
  'readonly' => null,
  'twelveHourFormat' => null,
  'userLimit' => 0,
  'zoom' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'administrator' => null,
  'attributes' => [
    
  ],
  'coordinateFormat' => '',
  'deviceLimit' => 0,
  'deviceReadonly' => null,
  'disabled' => null,
  'email' => '',
  'expirationTime' => '',
  'id' => 0,
  'latitude' => '',
  'limitCommands' => null,
  'longitude' => '',
  'map' => '',
  'name' => '',
  'password' => '',
  'phone' => '',
  'poiLayer' => '',
  'readonly' => null,
  'twelveHourFormat' => null,
  'userLimit' => 0,
  'zoom' => 0
]));
$request->setRequestUrl('{{baseUrl}}/users/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/users/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/users/:id"

payload = {
    "administrator": False,
    "attributes": {},
    "coordinateFormat": "",
    "deviceLimit": 0,
    "deviceReadonly": False,
    "disabled": False,
    "email": "",
    "expirationTime": "",
    "id": 0,
    "latitude": "",
    "limitCommands": False,
    "longitude": "",
    "map": "",
    "name": "",
    "password": "",
    "phone": "",
    "poiLayer": "",
    "readonly": False,
    "twelveHourFormat": False,
    "userLimit": 0,
    "zoom": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/users/:id"

payload <- "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/users/:id') do |req|
  req.body = "{\n  \"administrator\": false,\n  \"attributes\": {},\n  \"coordinateFormat\": \"\",\n  \"deviceLimit\": 0,\n  \"deviceReadonly\": false,\n  \"disabled\": false,\n  \"email\": \"\",\n  \"expirationTime\": \"\",\n  \"id\": 0,\n  \"latitude\": \"\",\n  \"limitCommands\": false,\n  \"longitude\": \"\",\n  \"map\": \"\",\n  \"name\": \"\",\n  \"password\": \"\",\n  \"phone\": \"\",\n  \"poiLayer\": \"\",\n  \"readonly\": false,\n  \"twelveHourFormat\": false,\n  \"userLimit\": 0,\n  \"zoom\": 0\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users/:id";

    let payload = json!({
        "administrator": false,
        "attributes": json!({}),
        "coordinateFormat": "",
        "deviceLimit": 0,
        "deviceReadonly": false,
        "disabled": false,
        "email": "",
        "expirationTime": "",
        "id": 0,
        "latitude": "",
        "limitCommands": false,
        "longitude": "",
        "map": "",
        "name": "",
        "password": "",
        "phone": "",
        "poiLayer": "",
        "readonly": false,
        "twelveHourFormat": false,
        "userLimit": 0,
        "zoom": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/users/:id \
  --header 'content-type: application/json' \
  --data '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}'
echo '{
  "administrator": false,
  "attributes": {},
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
}' |  \
  http PUT {{baseUrl}}/users/:id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "administrator": false,\n  "attributes": {},\n  "coordinateFormat": "",\n  "deviceLimit": 0,\n  "deviceReadonly": false,\n  "disabled": false,\n  "email": "",\n  "expirationTime": "",\n  "id": 0,\n  "latitude": "",\n  "limitCommands": false,\n  "longitude": "",\n  "map": "",\n  "name": "",\n  "password": "",\n  "phone": "",\n  "poiLayer": "",\n  "readonly": false,\n  "twelveHourFormat": false,\n  "userLimit": 0,\n  "zoom": 0\n}' \
  --output-document \
  - {{baseUrl}}/users/:id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "administrator": false,
  "attributes": [],
  "coordinateFormat": "",
  "deviceLimit": 0,
  "deviceReadonly": false,
  "disabled": false,
  "email": "",
  "expirationTime": "",
  "id": 0,
  "latitude": "",
  "limitCommands": false,
  "longitude": "",
  "map": "",
  "name": "",
  "password": "",
  "phone": "",
  "poiLayer": "",
  "readonly": false,
  "twelveHourFormat": false,
  "userLimit": 0,
  "zoom": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()