AWS IoT Wirelessv2020-11-22

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/partner-accounts");

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  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/partner-accounts" {:content-type :json
                                                             :form-params {:Sidewalk {:AmazonId ""
                                                                                      :AppServerPrivateKey ""}
                                                                           :ClientRequestToken ""
                                                                           :Tags [{:Key ""
                                                                                   :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/partner-accounts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/partner-accounts"),
    Content = new StringContent("{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/partner-accounts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/partner-accounts"

	payload := strings.NewReader("{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/partner-accounts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 165

{
  "Sidewalk": {
    "AmazonId": "",
    "AppServerPrivateKey": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/partner-accounts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/partner-accounts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/partner-accounts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/partner-accounts")
  .header("content-type", "application/json")
  .body("{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Sidewalk: {
    AmazonId: '',
    AppServerPrivateKey: ''
  },
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/partner-accounts',
  headers: {'content-type': 'application/json'},
  data: {
    Sidewalk: {AmazonId: '', AppServerPrivateKey: ''},
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/partner-accounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Sidewalk":{"AmazonId":"","AppServerPrivateKey":""},"ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/partner-accounts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Sidewalk": {\n    "AmazonId": "",\n    "AppServerPrivateKey": ""\n  },\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/partner-accounts")
  .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/partner-accounts',
  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({
  Sidewalk: {AmazonId: '', AppServerPrivateKey: ''},
  ClientRequestToken: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/partner-accounts',
  headers: {'content-type': 'application/json'},
  body: {
    Sidewalk: {AmazonId: '', AppServerPrivateKey: ''},
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  },
  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}}/partner-accounts');

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

req.type('json');
req.send({
  Sidewalk: {
    AmazonId: '',
    AppServerPrivateKey: ''
  },
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/partner-accounts',
  headers: {'content-type': 'application/json'},
  data: {
    Sidewalk: {AmazonId: '', AppServerPrivateKey: ''},
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/partner-accounts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Sidewalk":{"AmazonId":"","AppServerPrivateKey":""},"ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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 = @{ @"Sidewalk": @{ @"AmazonId": @"", @"AppServerPrivateKey": @"" },
                              @"ClientRequestToken": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/partner-accounts"]
                                                       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}}/partner-accounts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/partner-accounts",
  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([
    'Sidewalk' => [
        'AmazonId' => '',
        'AppServerPrivateKey' => ''
    ],
    'ClientRequestToken' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/partner-accounts', [
  'body' => '{
  "Sidewalk": {
    "AmazonId": "",
    "AppServerPrivateKey": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/partner-accounts');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Sidewalk' => [
    'AmazonId' => '',
    'AppServerPrivateKey' => ''
  ],
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Sidewalk' => [
    'AmazonId' => '',
    'AppServerPrivateKey' => ''
  ],
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/partner-accounts');
$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}}/partner-accounts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Sidewalk": {
    "AmazonId": "",
    "AppServerPrivateKey": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/partner-accounts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Sidewalk": {
    "AmazonId": "",
    "AppServerPrivateKey": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/partner-accounts", payload, headers)

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

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

import requests

url = "{{baseUrl}}/partner-accounts"

payload = {
    "Sidewalk": {
        "AmazonId": "",
        "AppServerPrivateKey": ""
    },
    "ClientRequestToken": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/partner-accounts"

payload <- "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/partner-accounts")

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  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/partner-accounts') do |req|
  req.body = "{\n  \"Sidewalk\": {\n    \"AmazonId\": \"\",\n    \"AppServerPrivateKey\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Sidewalk": json!({
            "AmazonId": "",
            "AppServerPrivateKey": ""
        }),
        "ClientRequestToken": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "Sidewalk": {
    "AmazonId": "",
    "AppServerPrivateKey": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/partner-accounts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Sidewalk": {\n    "AmazonId": "",\n    "AppServerPrivateKey": ""\n  },\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/partner-accounts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Sidewalk": [
    "AmazonId": "",
    "AppServerPrivateKey": ""
  ],
  "ClientRequestToken": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id/multicast-group");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/fuota-tasks/:Id/multicast-group" {:content-type :json
                                                                           :form-params {:MulticastGroupId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/fuota-tasks/:Id/multicast-group"

	payload := strings.NewReader("{\n  \"MulticastGroupId\": \"\"\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/fuota-tasks/:Id/multicast-group HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "MulticastGroupId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/fuota-tasks/:Id/multicast-group")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MulticastGroupId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/:Id/multicast-group"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"MulticastGroupId\": \"\"\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  \"MulticastGroupId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id/multicast-group")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/fuota-tasks/:Id/multicast-group")
  .header("content-type", "application/json")
  .body("{\n  \"MulticastGroupId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/fuota-tasks/:Id/multicast-group');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-group',
  headers: {'content-type': 'application/json'},
  data: {MulticastGroupId: ''}
};

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

const url = '{{baseUrl}}/fuota-tasks/:Id/multicast-group';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"MulticastGroupId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-group',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MulticastGroupId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-group',
  headers: {'content-type': 'application/json'},
  body: {MulticastGroupId: ''},
  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}}/fuota-tasks/:Id/multicast-group');

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

req.type('json');
req.send({
  MulticastGroupId: ''
});

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}}/fuota-tasks/:Id/multicast-group',
  headers: {'content-type': 'application/json'},
  data: {MulticastGroupId: ''}
};

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

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

const url = '{{baseUrl}}/fuota-tasks/:Id/multicast-group';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"MulticastGroupId":""}'
};

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

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

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

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

 "{{baseUrl}}/fuota-tasks/:Id/multicast-group",
  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([
    'MulticastGroupId' => ''
  ]),
  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}}/fuota-tasks/:Id/multicast-group', [
  'body' => '{
  "MulticastGroupId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id/multicast-group');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'MulticastGroupId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/fuota-tasks/:Id/multicast-group');
$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}}/fuota-tasks/:Id/multicast-group' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "MulticastGroupId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id/multicast-group' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "MulticastGroupId": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/fuota-tasks/:Id/multicast-group", payload, headers)

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

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

import requests

url = "{{baseUrl}}/fuota-tasks/:Id/multicast-group"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id/multicast-group"

payload <- "{\n  \"MulticastGroupId\": \"\"\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}}/fuota-tasks/:Id/multicast-group")

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  \"MulticastGroupId\": \"\"\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/fuota-tasks/:Id/multicast-group') do |req|
  req.body = "{\n  \"MulticastGroupId\": \"\"\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}}/fuota-tasks/:Id/multicast-group";

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

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

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

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

    dbg!(results);
}

echo '{
  "MulticastGroupId": ""
}' |  \
  http PUT {{baseUrl}}/fuota-tasks/:Id/multicast-group \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "MulticastGroupId": ""\n}' \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id/multicast-group

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id/multicast-group")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id/wireless-device");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/fuota-tasks/:Id/wireless-device" {:content-type :json
                                                                           :form-params {:WirelessDeviceId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/fuota-tasks/:Id/wireless-device"

	payload := strings.NewReader("{\n  \"WirelessDeviceId\": \"\"\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/fuota-tasks/:Id/wireless-device HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "WirelessDeviceId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/fuota-tasks/:Id/wireless-device")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WirelessDeviceId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/:Id/wireless-device"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"WirelessDeviceId\": \"\"\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  \"WirelessDeviceId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id/wireless-device")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/fuota-tasks/:Id/wireless-device")
  .header("content-type", "application/json")
  .body("{\n  \"WirelessDeviceId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/fuota-tasks/:Id/wireless-device');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fuota-tasks/:Id/wireless-device',
  headers: {'content-type': 'application/json'},
  data: {WirelessDeviceId: ''}
};

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

const url = '{{baseUrl}}/fuota-tasks/:Id/wireless-device';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"WirelessDeviceId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/fuota-tasks/:Id/wireless-device',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WirelessDeviceId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fuota-tasks/:Id/wireless-device',
  headers: {'content-type': 'application/json'},
  body: {WirelessDeviceId: ''},
  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}}/fuota-tasks/:Id/wireless-device');

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

req.type('json');
req.send({
  WirelessDeviceId: ''
});

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}}/fuota-tasks/:Id/wireless-device',
  headers: {'content-type': 'application/json'},
  data: {WirelessDeviceId: ''}
};

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

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

const url = '{{baseUrl}}/fuota-tasks/:Id/wireless-device';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"WirelessDeviceId":""}'
};

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

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

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

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

 "{{baseUrl}}/fuota-tasks/:Id/wireless-device",
  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([
    'WirelessDeviceId' => ''
  ]),
  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}}/fuota-tasks/:Id/wireless-device', [
  'body' => '{
  "WirelessDeviceId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id/wireless-device');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'WirelessDeviceId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/fuota-tasks/:Id/wireless-device');
$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}}/fuota-tasks/:Id/wireless-device' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "WirelessDeviceId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id/wireless-device' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "WirelessDeviceId": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/fuota-tasks/:Id/wireless-device", payload, headers)

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

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

import requests

url = "{{baseUrl}}/fuota-tasks/:Id/wireless-device"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id/wireless-device"

payload <- "{\n  \"WirelessDeviceId\": \"\"\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}}/fuota-tasks/:Id/wireless-device")

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  \"WirelessDeviceId\": \"\"\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/fuota-tasks/:Id/wireless-device') do |req|
  req.body = "{\n  \"WirelessDeviceId\": \"\"\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}}/fuota-tasks/:Id/wireless-device";

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

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

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

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

    dbg!(results);
}

echo '{
  "WirelessDeviceId": ""
}' |  \
  http PUT {{baseUrl}}/fuota-tasks/:Id/wireless-device \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "WirelessDeviceId": ""\n}' \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id/wireless-device

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id/wireless-device")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/wireless-device");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/multicast-groups/:Id/wireless-device" {:content-type :json
                                                                                :form-params {:WirelessDeviceId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id/wireless-device"

	payload := strings.NewReader("{\n  \"WirelessDeviceId\": \"\"\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/multicast-groups/:Id/wireless-device HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "WirelessDeviceId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/multicast-groups/:Id/wireless-device")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WirelessDeviceId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/:Id/wireless-device"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"WirelessDeviceId\": \"\"\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  \"WirelessDeviceId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/wireless-device")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/multicast-groups/:Id/wireless-device")
  .header("content-type", "application/json")
  .body("{\n  \"WirelessDeviceId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/multicast-groups/:Id/wireless-device');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/multicast-groups/:Id/wireless-device',
  headers: {'content-type': 'application/json'},
  data: {WirelessDeviceId: ''}
};

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

const url = '{{baseUrl}}/multicast-groups/:Id/wireless-device';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"WirelessDeviceId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/multicast-groups/:Id/wireless-device',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WirelessDeviceId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/multicast-groups/:Id/wireless-device',
  headers: {'content-type': 'application/json'},
  body: {WirelessDeviceId: ''},
  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}}/multicast-groups/:Id/wireless-device');

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

req.type('json');
req.send({
  WirelessDeviceId: ''
});

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}}/multicast-groups/:Id/wireless-device',
  headers: {'content-type': 'application/json'},
  data: {WirelessDeviceId: ''}
};

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

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

const url = '{{baseUrl}}/multicast-groups/:Id/wireless-device';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"WirelessDeviceId":""}'
};

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

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

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

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

 "{{baseUrl}}/multicast-groups/:Id/wireless-device",
  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([
    'WirelessDeviceId' => ''
  ]),
  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}}/multicast-groups/:Id/wireless-device', [
  'body' => '{
  "WirelessDeviceId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/wireless-device');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'WirelessDeviceId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/multicast-groups/:Id/wireless-device');
$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}}/multicast-groups/:Id/wireless-device' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "WirelessDeviceId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/wireless-device' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "WirelessDeviceId": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/multicast-groups/:Id/wireless-device", payload, headers)

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

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

import requests

url = "{{baseUrl}}/multicast-groups/:Id/wireless-device"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/wireless-device"

payload <- "{\n  \"WirelessDeviceId\": \"\"\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}}/multicast-groups/:Id/wireless-device")

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  \"WirelessDeviceId\": \"\"\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/multicast-groups/:Id/wireless-device') do |req|
  req.body = "{\n  \"WirelessDeviceId\": \"\"\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}}/multicast-groups/:Id/wireless-device";

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

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

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

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

    dbg!(results);
}

echo '{
  "WirelessDeviceId": ""
}' |  \
  http PUT {{baseUrl}}/multicast-groups/:Id/wireless-device \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "WirelessDeviceId": ""\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/wireless-device

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/wireless-device")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id/thing");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/wireless-devices/:Id/thing" {:content-type :json
                                                                      :form-params {:ThingArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/wireless-devices/:Id/thing"

	payload := strings.NewReader("{\n  \"ThingArn\": \"\"\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/wireless-devices/:Id/thing HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "ThingArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/wireless-devices/:Id/thing")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ThingArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/thing"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ThingArn\": \"\"\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  \"ThingArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/thing")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/wireless-devices/:Id/thing")
  .header("content-type", "application/json")
  .body("{\n  \"ThingArn\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/wireless-devices/:Id/thing');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/wireless-devices/:Id/thing',
  headers: {'content-type': 'application/json'},
  data: {ThingArn: ''}
};

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

const url = '{{baseUrl}}/wireless-devices/:Id/thing';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ThingArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-devices/:Id/thing',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ThingArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/wireless-devices/:Id/thing',
  headers: {'content-type': 'application/json'},
  body: {ThingArn: ''},
  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}}/wireless-devices/:Id/thing');

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

req.type('json');
req.send({
  ThingArn: ''
});

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}}/wireless-devices/:Id/thing',
  headers: {'content-type': 'application/json'},
  data: {ThingArn: ''}
};

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

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

const url = '{{baseUrl}}/wireless-devices/:Id/thing';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ThingArn":""}'
};

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

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

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

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

 "{{baseUrl}}/wireless-devices/:Id/thing",
  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([
    'ThingArn' => ''
  ]),
  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}}/wireless-devices/:Id/thing', [
  'body' => '{
  "ThingArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id/thing');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'ThingArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/wireless-devices/:Id/thing');
$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}}/wireless-devices/:Id/thing' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ThingArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/thing' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ThingArn": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/wireless-devices/:Id/thing", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-devices/:Id/thing"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id/thing"

payload <- "{\n  \"ThingArn\": \"\"\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}}/wireless-devices/:Id/thing")

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  \"ThingArn\": \"\"\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/wireless-devices/:Id/thing') do |req|
  req.body = "{\n  \"ThingArn\": \"\"\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}}/wireless-devices/:Id/thing";

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

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

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

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

    dbg!(results);
}

echo '{
  "ThingArn": ""
}' |  \
  http PUT {{baseUrl}}/wireless-devices/:Id/thing \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ThingArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id/thing

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/certificate");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/wireless-gateways/:Id/certificate" {:content-type :json
                                                                             :form-params {:IotCertificateId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id/certificate"

	payload := strings.NewReader("{\n  \"IotCertificateId\": \"\"\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/wireless-gateways/:Id/certificate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "IotCertificateId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/wireless-gateways/:Id/certificate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"IotCertificateId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/certificate"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"IotCertificateId\": \"\"\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  \"IotCertificateId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/certificate")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/wireless-gateways/:Id/certificate")
  .header("content-type", "application/json")
  .body("{\n  \"IotCertificateId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/wireless-gateways/:Id/certificate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/wireless-gateways/:Id/certificate',
  headers: {'content-type': 'application/json'},
  data: {IotCertificateId: ''}
};

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

const url = '{{baseUrl}}/wireless-gateways/:Id/certificate';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"IotCertificateId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-gateways/:Id/certificate',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "IotCertificateId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/wireless-gateways/:Id/certificate',
  headers: {'content-type': 'application/json'},
  body: {IotCertificateId: ''},
  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}}/wireless-gateways/:Id/certificate');

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

req.type('json');
req.send({
  IotCertificateId: ''
});

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}}/wireless-gateways/:Id/certificate',
  headers: {'content-type': 'application/json'},
  data: {IotCertificateId: ''}
};

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

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

const url = '{{baseUrl}}/wireless-gateways/:Id/certificate';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"IotCertificateId":""}'
};

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

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

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

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

 "{{baseUrl}}/wireless-gateways/:Id/certificate",
  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([
    'IotCertificateId' => ''
  ]),
  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}}/wireless-gateways/:Id/certificate', [
  'body' => '{
  "IotCertificateId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/certificate');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'IotCertificateId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/certificate');
$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}}/wireless-gateways/:Id/certificate' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "IotCertificateId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/certificate' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "IotCertificateId": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/wireless-gateways/:Id/certificate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-gateways/:Id/certificate"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id/certificate"

payload <- "{\n  \"IotCertificateId\": \"\"\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}}/wireless-gateways/:Id/certificate")

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  \"IotCertificateId\": \"\"\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/wireless-gateways/:Id/certificate') do |req|
  req.body = "{\n  \"IotCertificateId\": \"\"\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}}/wireless-gateways/:Id/certificate";

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

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

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

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

    dbg!(results);
}

echo '{
  "IotCertificateId": ""
}' |  \
  http PUT {{baseUrl}}/wireless-gateways/:Id/certificate \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "IotCertificateId": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/certificate

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/thing");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/wireless-gateways/:Id/thing" {:content-type :json
                                                                       :form-params {:ThingArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id/thing"

	payload := strings.NewReader("{\n  \"ThingArn\": \"\"\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/wireless-gateways/:Id/thing HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "ThingArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/wireless-gateways/:Id/thing")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ThingArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/thing"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ThingArn\": \"\"\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  \"ThingArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/thing")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/wireless-gateways/:Id/thing")
  .header("content-type", "application/json")
  .body("{\n  \"ThingArn\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/wireless-gateways/:Id/thing');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/wireless-gateways/:Id/thing',
  headers: {'content-type': 'application/json'},
  data: {ThingArn: ''}
};

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

const url = '{{baseUrl}}/wireless-gateways/:Id/thing';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ThingArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-gateways/:Id/thing',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ThingArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/wireless-gateways/:Id/thing',
  headers: {'content-type': 'application/json'},
  body: {ThingArn: ''},
  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}}/wireless-gateways/:Id/thing');

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

req.type('json');
req.send({
  ThingArn: ''
});

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}}/wireless-gateways/:Id/thing',
  headers: {'content-type': 'application/json'},
  data: {ThingArn: ''}
};

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

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

const url = '{{baseUrl}}/wireless-gateways/:Id/thing';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ThingArn":""}'
};

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

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

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

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

 "{{baseUrl}}/wireless-gateways/:Id/thing",
  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([
    'ThingArn' => ''
  ]),
  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}}/wireless-gateways/:Id/thing', [
  'body' => '{
  "ThingArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/thing');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'ThingArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/thing');
$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}}/wireless-gateways/:Id/thing' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ThingArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/thing' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ThingArn": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/wireless-gateways/:Id/thing", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-gateways/:Id/thing"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id/thing"

payload <- "{\n  \"ThingArn\": \"\"\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}}/wireless-gateways/:Id/thing")

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  \"ThingArn\": \"\"\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/wireless-gateways/:Id/thing') do |req|
  req.body = "{\n  \"ThingArn\": \"\"\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}}/wireless-gateways/:Id/thing";

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

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

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

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

    dbg!(results);
}

echo '{
  "ThingArn": ""
}' |  \
  http PUT {{baseUrl}}/wireless-gateways/:Id/thing \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ThingArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/thing

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/session");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/multicast-groups/:Id/session")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/multicast-groups/:Id/session");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id/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/multicast-groups/:Id/session HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/multicast-groups/:Id/session")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/multicast-groups/:Id/session'
};

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

const url = '{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/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/multicast-groups/:Id/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}}/multicast-groups/:Id/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}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session'
};

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

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

const url = '{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session" in

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

 "{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session');

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/session');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/multicast-groups/:Id/session');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/multicast-groups/:Id/session' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/session' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/multicast-groups/:Id/session")

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

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

import requests

url = "{{baseUrl}}/multicast-groups/:Id/session"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/session"

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

content(response, "text")

require 'uri'
require 'net/http'

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

http DELETE {{baseUrl}}/multicast-groups/:Id/session

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/session

import Foundation

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

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/destinations" {:content-type :json
                                                         :form-params {:Name ""
                                                                       :ExpressionType ""
                                                                       :Expression ""
                                                                       :Description ""
                                                                       :RoleArn ""
                                                                       :Tags [{:Key ""
                                                                               :Value ""}]
                                                                       :ClientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/destinations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/destinations"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/destinations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/destinations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 190

{
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/destinations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/destinations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/destinations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/destinations")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  ExpressionType: '',
  Expression: '',
  Description: '',
  RoleArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/destinations',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    ExpressionType: '',
    Expression: '',
    Description: '',
    RoleArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/destinations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","ExpressionType":"","Expression":"","Description":"","RoleArn":"","Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/destinations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "ExpressionType": "",\n  "Expression": "",\n  "Description": "",\n  "RoleArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/destinations")
  .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/destinations',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  ExpressionType: '',
  Expression: '',
  Description: '',
  RoleArn: '',
  Tags: [{Key: '', Value: ''}],
  ClientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/destinations',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    ExpressionType: '',
    Expression: '',
    Description: '',
    RoleArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  },
  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}}/destinations');

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

req.type('json');
req.send({
  Name: '',
  ExpressionType: '',
  Expression: '',
  Description: '',
  RoleArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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}}/destinations',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    ExpressionType: '',
    Expression: '',
    Description: '',
    RoleArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/destinations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","ExpressionType":"","Expression":"","Description":"","RoleArn":"","Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"ExpressionType": @"",
                              @"Expression": @"",
                              @"Description": @"",
                              @"RoleArn": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/destinations"]
                                                       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}}/destinations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/destinations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'ExpressionType' => '',
    'Expression' => '',
    'Description' => '',
    'RoleArn' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientRequestToken' => ''
  ]),
  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}}/destinations', [
  'body' => '{
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'ExpressionType' => '',
  'Expression' => '',
  'Description' => '',
  'RoleArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'ExpressionType' => '',
  'Expression' => '',
  'Description' => '',
  'RoleArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/destinations');
$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}}/destinations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/destinations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/destinations"

payload = {
    "Name": "",
    "ExpressionType": "",
    "Expression": "",
    "Description": "",
    "RoleArn": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/destinations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/destinations') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "ExpressionType": "",
        "Expression": "",
        "Description": "",
        "RoleArn": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/destinations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "ExpressionType": "",\n  "Expression": "",\n  "Description": "",\n  "RoleArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/destinations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/device-profiles");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/device-profiles" {:content-type :json
                                                            :form-params {:Name ""
                                                                          :LoRaWAN {:SupportsClassB ""
                                                                                    :ClassBTimeout ""
                                                                                    :PingSlotPeriod ""
                                                                                    :PingSlotDr ""
                                                                                    :PingSlotFreq ""
                                                                                    :SupportsClassC ""
                                                                                    :ClassCTimeout ""
                                                                                    :MacVersion ""
                                                                                    :RegParamsRevision ""
                                                                                    :RxDelay1 ""
                                                                                    :RxDrOffset1 ""
                                                                                    :RxDataRate2 ""
                                                                                    :RxFreq2 ""
                                                                                    :FactoryPresetFreqsList ""
                                                                                    :MaxEirp ""
                                                                                    :MaxDutyCycle ""
                                                                                    :RfRegion ""
                                                                                    :SupportsJoin ""
                                                                                    :Supports32BitFCnt ""}
                                                                          :Tags [{:Key ""
                                                                                  :Value ""}]
                                                                          :ClientRequestToken ""
                                                                          :Sidewalk {}}})

require "http/client"

url = "{{baseUrl}}/device-profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\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}}/device-profiles"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\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}}/device-profiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/device-profiles"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\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/device-profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 605

{
  "Name": "",
  "LoRaWAN": {
    "SupportsClassB": "",
    "ClassBTimeout": "",
    "PingSlotPeriod": "",
    "PingSlotDr": "",
    "PingSlotFreq": "",
    "SupportsClassC": "",
    "ClassCTimeout": "",
    "MacVersion": "",
    "RegParamsRevision": "",
    "RxDelay1": "",
    "RxDrOffset1": "",
    "RxDataRate2": "",
    "RxFreq2": "",
    "FactoryPresetFreqsList": "",
    "MaxEirp": "",
    "MaxDutyCycle": "",
    "RfRegion": "",
    "SupportsJoin": "",
    "Supports32BitFCnt": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": "",
  "Sidewalk": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/device-profiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/device-profiles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/device-profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/device-profiles")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  LoRaWAN: {
    SupportsClassB: '',
    ClassBTimeout: '',
    PingSlotPeriod: '',
    PingSlotDr: '',
    PingSlotFreq: '',
    SupportsClassC: '',
    ClassCTimeout: '',
    MacVersion: '',
    RegParamsRevision: '',
    RxDelay1: '',
    RxDrOffset1: '',
    RxDataRate2: '',
    RxFreq2: '',
    FactoryPresetFreqsList: '',
    MaxEirp: '',
    MaxDutyCycle: '',
    RfRegion: '',
    SupportsJoin: '',
    Supports32BitFCnt: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: '',
  Sidewalk: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/device-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    LoRaWAN: {
      SupportsClassB: '',
      ClassBTimeout: '',
      PingSlotPeriod: '',
      PingSlotDr: '',
      PingSlotFreq: '',
      SupportsClassC: '',
      ClassCTimeout: '',
      MacVersion: '',
      RegParamsRevision: '',
      RxDelay1: '',
      RxDrOffset1: '',
      RxDataRate2: '',
      RxFreq2: '',
      FactoryPresetFreqsList: '',
      MaxEirp: '',
      MaxDutyCycle: '',
      RfRegion: '',
      SupportsJoin: '',
      Supports32BitFCnt: ''
    },
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: '',
    Sidewalk: {}
  }
};

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

const url = '{{baseUrl}}/device-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","LoRaWAN":{"SupportsClassB":"","ClassBTimeout":"","PingSlotPeriod":"","PingSlotDr":"","PingSlotFreq":"","SupportsClassC":"","ClassCTimeout":"","MacVersion":"","RegParamsRevision":"","RxDelay1":"","RxDrOffset1":"","RxDataRate2":"","RxFreq2":"","FactoryPresetFreqsList":"","MaxEirp":"","MaxDutyCycle":"","RfRegion":"","SupportsJoin":"","Supports32BitFCnt":""},"Tags":[{"Key":"","Value":""}],"ClientRequestToken":"","Sidewalk":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/device-profiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "LoRaWAN": {\n    "SupportsClassB": "",\n    "ClassBTimeout": "",\n    "PingSlotPeriod": "",\n    "PingSlotDr": "",\n    "PingSlotFreq": "",\n    "SupportsClassC": "",\n    "ClassCTimeout": "",\n    "MacVersion": "",\n    "RegParamsRevision": "",\n    "RxDelay1": "",\n    "RxDrOffset1": "",\n    "RxDataRate2": "",\n    "RxFreq2": "",\n    "FactoryPresetFreqsList": "",\n    "MaxEirp": "",\n    "MaxDutyCycle": "",\n    "RfRegion": "",\n    "SupportsJoin": "",\n    "Supports32BitFCnt": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": "",\n  "Sidewalk": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/device-profiles")
  .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/device-profiles',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  LoRaWAN: {
    SupportsClassB: '',
    ClassBTimeout: '',
    PingSlotPeriod: '',
    PingSlotDr: '',
    PingSlotFreq: '',
    SupportsClassC: '',
    ClassCTimeout: '',
    MacVersion: '',
    RegParamsRevision: '',
    RxDelay1: '',
    RxDrOffset1: '',
    RxDataRate2: '',
    RxFreq2: '',
    FactoryPresetFreqsList: '',
    MaxEirp: '',
    MaxDutyCycle: '',
    RfRegion: '',
    SupportsJoin: '',
    Supports32BitFCnt: ''
  },
  Tags: [{Key: '', Value: ''}],
  ClientRequestToken: '',
  Sidewalk: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/device-profiles',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    LoRaWAN: {
      SupportsClassB: '',
      ClassBTimeout: '',
      PingSlotPeriod: '',
      PingSlotDr: '',
      PingSlotFreq: '',
      SupportsClassC: '',
      ClassCTimeout: '',
      MacVersion: '',
      RegParamsRevision: '',
      RxDelay1: '',
      RxDrOffset1: '',
      RxDataRate2: '',
      RxFreq2: '',
      FactoryPresetFreqsList: '',
      MaxEirp: '',
      MaxDutyCycle: '',
      RfRegion: '',
      SupportsJoin: '',
      Supports32BitFCnt: ''
    },
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: '',
    Sidewalk: {}
  },
  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}}/device-profiles');

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

req.type('json');
req.send({
  Name: '',
  LoRaWAN: {
    SupportsClassB: '',
    ClassBTimeout: '',
    PingSlotPeriod: '',
    PingSlotDr: '',
    PingSlotFreq: '',
    SupportsClassC: '',
    ClassCTimeout: '',
    MacVersion: '',
    RegParamsRevision: '',
    RxDelay1: '',
    RxDrOffset1: '',
    RxDataRate2: '',
    RxFreq2: '',
    FactoryPresetFreqsList: '',
    MaxEirp: '',
    MaxDutyCycle: '',
    RfRegion: '',
    SupportsJoin: '',
    Supports32BitFCnt: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: '',
  Sidewalk: {}
});

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}}/device-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    LoRaWAN: {
      SupportsClassB: '',
      ClassBTimeout: '',
      PingSlotPeriod: '',
      PingSlotDr: '',
      PingSlotFreq: '',
      SupportsClassC: '',
      ClassCTimeout: '',
      MacVersion: '',
      RegParamsRevision: '',
      RxDelay1: '',
      RxDrOffset1: '',
      RxDataRate2: '',
      RxFreq2: '',
      FactoryPresetFreqsList: '',
      MaxEirp: '',
      MaxDutyCycle: '',
      RfRegion: '',
      SupportsJoin: '',
      Supports32BitFCnt: ''
    },
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: '',
    Sidewalk: {}
  }
};

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

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

const url = '{{baseUrl}}/device-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","LoRaWAN":{"SupportsClassB":"","ClassBTimeout":"","PingSlotPeriod":"","PingSlotDr":"","PingSlotFreq":"","SupportsClassC":"","ClassCTimeout":"","MacVersion":"","RegParamsRevision":"","RxDelay1":"","RxDrOffset1":"","RxDataRate2":"","RxFreq2":"","FactoryPresetFreqsList":"","MaxEirp":"","MaxDutyCycle":"","RfRegion":"","SupportsJoin":"","Supports32BitFCnt":""},"Tags":[{"Key":"","Value":""}],"ClientRequestToken":"","Sidewalk":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"LoRaWAN": @{ @"SupportsClassB": @"", @"ClassBTimeout": @"", @"PingSlotPeriod": @"", @"PingSlotDr": @"", @"PingSlotFreq": @"", @"SupportsClassC": @"", @"ClassCTimeout": @"", @"MacVersion": @"", @"RegParamsRevision": @"", @"RxDelay1": @"", @"RxDrOffset1": @"", @"RxDataRate2": @"", @"RxFreq2": @"", @"FactoryPresetFreqsList": @"", @"MaxEirp": @"", @"MaxDutyCycle": @"", @"RfRegion": @"", @"SupportsJoin": @"", @"Supports32BitFCnt": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientRequestToken": @"",
                              @"Sidewalk": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/device-profiles"]
                                                       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}}/device-profiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}" in

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

 "{{baseUrl}}/device-profiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'LoRaWAN' => [
        'SupportsClassB' => '',
        'ClassBTimeout' => '',
        'PingSlotPeriod' => '',
        'PingSlotDr' => '',
        'PingSlotFreq' => '',
        'SupportsClassC' => '',
        'ClassCTimeout' => '',
        'MacVersion' => '',
        'RegParamsRevision' => '',
        'RxDelay1' => '',
        'RxDrOffset1' => '',
        'RxDataRate2' => '',
        'RxFreq2' => '',
        'FactoryPresetFreqsList' => '',
        'MaxEirp' => '',
        'MaxDutyCycle' => '',
        'RfRegion' => '',
        'SupportsJoin' => '',
        'Supports32BitFCnt' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientRequestToken' => '',
    'Sidewalk' => [
        
    ]
  ]),
  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}}/device-profiles', [
  'body' => '{
  "Name": "",
  "LoRaWAN": {
    "SupportsClassB": "",
    "ClassBTimeout": "",
    "PingSlotPeriod": "",
    "PingSlotDr": "",
    "PingSlotFreq": "",
    "SupportsClassC": "",
    "ClassCTimeout": "",
    "MacVersion": "",
    "RegParamsRevision": "",
    "RxDelay1": "",
    "RxDrOffset1": "",
    "RxDataRate2": "",
    "RxFreq2": "",
    "FactoryPresetFreqsList": "",
    "MaxEirp": "",
    "MaxDutyCycle": "",
    "RfRegion": "",
    "SupportsJoin": "",
    "Supports32BitFCnt": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": "",
  "Sidewalk": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/device-profiles');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'LoRaWAN' => [
    'SupportsClassB' => '',
    'ClassBTimeout' => '',
    'PingSlotPeriod' => '',
    'PingSlotDr' => '',
    'PingSlotFreq' => '',
    'SupportsClassC' => '',
    'ClassCTimeout' => '',
    'MacVersion' => '',
    'RegParamsRevision' => '',
    'RxDelay1' => '',
    'RxDrOffset1' => '',
    'RxDataRate2' => '',
    'RxFreq2' => '',
    'FactoryPresetFreqsList' => '',
    'MaxEirp' => '',
    'MaxDutyCycle' => '',
    'RfRegion' => '',
    'SupportsJoin' => '',
    'Supports32BitFCnt' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => '',
  'Sidewalk' => [
    
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'LoRaWAN' => [
    'SupportsClassB' => '',
    'ClassBTimeout' => '',
    'PingSlotPeriod' => '',
    'PingSlotDr' => '',
    'PingSlotFreq' => '',
    'SupportsClassC' => '',
    'ClassCTimeout' => '',
    'MacVersion' => '',
    'RegParamsRevision' => '',
    'RxDelay1' => '',
    'RxDrOffset1' => '',
    'RxDataRate2' => '',
    'RxFreq2' => '',
    'FactoryPresetFreqsList' => '',
    'MaxEirp' => '',
    'MaxDutyCycle' => '',
    'RfRegion' => '',
    'SupportsJoin' => '',
    'Supports32BitFCnt' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => '',
  'Sidewalk' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/device-profiles');
$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}}/device-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "LoRaWAN": {
    "SupportsClassB": "",
    "ClassBTimeout": "",
    "PingSlotPeriod": "",
    "PingSlotDr": "",
    "PingSlotFreq": "",
    "SupportsClassC": "",
    "ClassCTimeout": "",
    "MacVersion": "",
    "RegParamsRevision": "",
    "RxDelay1": "",
    "RxDrOffset1": "",
    "RxDataRate2": "",
    "RxFreq2": "",
    "FactoryPresetFreqsList": "",
    "MaxEirp": "",
    "MaxDutyCycle": "",
    "RfRegion": "",
    "SupportsJoin": "",
    "Supports32BitFCnt": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": "",
  "Sidewalk": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/device-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "LoRaWAN": {
    "SupportsClassB": "",
    "ClassBTimeout": "",
    "PingSlotPeriod": "",
    "PingSlotDr": "",
    "PingSlotFreq": "",
    "SupportsClassC": "",
    "ClassCTimeout": "",
    "MacVersion": "",
    "RegParamsRevision": "",
    "RxDelay1": "",
    "RxDrOffset1": "",
    "RxDataRate2": "",
    "RxFreq2": "",
    "FactoryPresetFreqsList": "",
    "MaxEirp": "",
    "MaxDutyCycle": "",
    "RfRegion": "",
    "SupportsJoin": "",
    "Supports32BitFCnt": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": "",
  "Sidewalk": {}
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}"

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

conn.request("POST", "/baseUrl/device-profiles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/device-profiles"

payload = {
    "Name": "",
    "LoRaWAN": {
        "SupportsClassB": "",
        "ClassBTimeout": "",
        "PingSlotPeriod": "",
        "PingSlotDr": "",
        "PingSlotFreq": "",
        "SupportsClassC": "",
        "ClassCTimeout": "",
        "MacVersion": "",
        "RegParamsRevision": "",
        "RxDelay1": "",
        "RxDrOffset1": "",
        "RxDataRate2": "",
        "RxFreq2": "",
        "FactoryPresetFreqsList": "",
        "MaxEirp": "",
        "MaxDutyCycle": "",
        "RfRegion": "",
        "SupportsJoin": "",
        "Supports32BitFCnt": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientRequestToken": "",
    "Sidewalk": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/device-profiles"

payload <- "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\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}}/device-profiles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\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/device-profiles') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"SupportsClassB\": \"\",\n    \"ClassBTimeout\": \"\",\n    \"PingSlotPeriod\": \"\",\n    \"PingSlotDr\": \"\",\n    \"PingSlotFreq\": \"\",\n    \"SupportsClassC\": \"\",\n    \"ClassCTimeout\": \"\",\n    \"MacVersion\": \"\",\n    \"RegParamsRevision\": \"\",\n    \"RxDelay1\": \"\",\n    \"RxDrOffset1\": \"\",\n    \"RxDataRate2\": \"\",\n    \"RxFreq2\": \"\",\n    \"FactoryPresetFreqsList\": \"\",\n    \"MaxEirp\": \"\",\n    \"MaxDutyCycle\": \"\",\n    \"RfRegion\": \"\",\n    \"SupportsJoin\": \"\",\n    \"Supports32BitFCnt\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\",\n  \"Sidewalk\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "LoRaWAN": json!({
            "SupportsClassB": "",
            "ClassBTimeout": "",
            "PingSlotPeriod": "",
            "PingSlotDr": "",
            "PingSlotFreq": "",
            "SupportsClassC": "",
            "ClassCTimeout": "",
            "MacVersion": "",
            "RegParamsRevision": "",
            "RxDelay1": "",
            "RxDrOffset1": "",
            "RxDataRate2": "",
            "RxFreq2": "",
            "FactoryPresetFreqsList": "",
            "MaxEirp": "",
            "MaxDutyCycle": "",
            "RfRegion": "",
            "SupportsJoin": "",
            "Supports32BitFCnt": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientRequestToken": "",
        "Sidewalk": json!({})
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "LoRaWAN": {
    "SupportsClassB": "",
    "ClassBTimeout": "",
    "PingSlotPeriod": "",
    "PingSlotDr": "",
    "PingSlotFreq": "",
    "SupportsClassC": "",
    "ClassCTimeout": "",
    "MacVersion": "",
    "RegParamsRevision": "",
    "RxDelay1": "",
    "RxDrOffset1": "",
    "RxDataRate2": "",
    "RxFreq2": "",
    "FactoryPresetFreqsList": "",
    "MaxEirp": "",
    "MaxDutyCycle": "",
    "RfRegion": "",
    "SupportsJoin": "",
    "Supports32BitFCnt": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": "",
  "Sidewalk": {}
}' |  \
  http POST {{baseUrl}}/device-profiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "LoRaWAN": {\n    "SupportsClassB": "",\n    "ClassBTimeout": "",\n    "PingSlotPeriod": "",\n    "PingSlotDr": "",\n    "PingSlotFreq": "",\n    "SupportsClassC": "",\n    "ClassCTimeout": "",\n    "MacVersion": "",\n    "RegParamsRevision": "",\n    "RxDelay1": "",\n    "RxDrOffset1": "",\n    "RxDataRate2": "",\n    "RxFreq2": "",\n    "FactoryPresetFreqsList": "",\n    "MaxEirp": "",\n    "MaxDutyCycle": "",\n    "RfRegion": "",\n    "SupportsJoin": "",\n    "Supports32BitFCnt": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": "",\n  "Sidewalk": {}\n}' \
  --output-document \
  - {{baseUrl}}/device-profiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "LoRaWAN": [
    "SupportsClassB": "",
    "ClassBTimeout": "",
    "PingSlotPeriod": "",
    "PingSlotDr": "",
    "PingSlotFreq": "",
    "SupportsClassC": "",
    "ClassCTimeout": "",
    "MacVersion": "",
    "RegParamsRevision": "",
    "RxDelay1": "",
    "RxDrOffset1": "",
    "RxDataRate2": "",
    "RxFreq2": "",
    "FactoryPresetFreqsList": "",
    "MaxEirp": "",
    "MaxDutyCycle": "",
    "RfRegion": "",
    "SupportsJoin": "",
    "Supports32BitFCnt": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientRequestToken": "",
  "Sidewalk": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/fuota-tasks" {:content-type :json
                                                        :form-params {:Name ""
                                                                      :Description ""
                                                                      :ClientRequestToken ""
                                                                      :LoRaWAN {:RfRegion ""}
                                                                      :FirmwareUpdateImage ""
                                                                      :FirmwareUpdateRole ""
                                                                      :Tags [{:Key ""
                                                                              :Value ""}]
                                                                      :RedundancyPercent 0
                                                                      :FragmentSizeBytes 0
                                                                      :FragmentIntervalMS 0}})

require "http/client"

url = "{{baseUrl}}/fuota-tasks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 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}}/fuota-tasks"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 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}}/fuota-tasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/fuota-tasks"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 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/fuota-tasks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 304

{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/fuota-tasks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/fuota-tasks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/fuota-tasks")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  ClientRequestToken: '',
  LoRaWAN: {
    RfRegion: ''
  },
  FirmwareUpdateImage: '',
  FirmwareUpdateRole: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  RedundancyPercent: 0,
  FragmentSizeBytes: 0,
  FragmentIntervalMS: 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}}/fuota-tasks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/fuota-tasks',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    ClientRequestToken: '',
    LoRaWAN: {RfRegion: ''},
    FirmwareUpdateImage: '',
    FirmwareUpdateRole: '',
    Tags: [{Key: '', Value: ''}],
    RedundancyPercent: 0,
    FragmentSizeBytes: 0,
    FragmentIntervalMS: 0
  }
};

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

const url = '{{baseUrl}}/fuota-tasks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","ClientRequestToken":"","LoRaWAN":{"RfRegion":""},"FirmwareUpdateImage":"","FirmwareUpdateRole":"","Tags":[{"Key":"","Value":""}],"RedundancyPercent":0,"FragmentSizeBytes":0,"FragmentIntervalMS":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}}/fuota-tasks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "ClientRequestToken": "",\n  "LoRaWAN": {\n    "RfRegion": ""\n  },\n  "FirmwareUpdateImage": "",\n  "FirmwareUpdateRole": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "RedundancyPercent": 0,\n  "FragmentSizeBytes": 0,\n  "FragmentIntervalMS": 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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks")
  .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/fuota-tasks',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  Description: '',
  ClientRequestToken: '',
  LoRaWAN: {RfRegion: ''},
  FirmwareUpdateImage: '',
  FirmwareUpdateRole: '',
  Tags: [{Key: '', Value: ''}],
  RedundancyPercent: 0,
  FragmentSizeBytes: 0,
  FragmentIntervalMS: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/fuota-tasks',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    ClientRequestToken: '',
    LoRaWAN: {RfRegion: ''},
    FirmwareUpdateImage: '',
    FirmwareUpdateRole: '',
    Tags: [{Key: '', Value: ''}],
    RedundancyPercent: 0,
    FragmentSizeBytes: 0,
    FragmentIntervalMS: 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}}/fuota-tasks');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  ClientRequestToken: '',
  LoRaWAN: {
    RfRegion: ''
  },
  FirmwareUpdateImage: '',
  FirmwareUpdateRole: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  RedundancyPercent: 0,
  FragmentSizeBytes: 0,
  FragmentIntervalMS: 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}}/fuota-tasks',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    ClientRequestToken: '',
    LoRaWAN: {RfRegion: ''},
    FirmwareUpdateImage: '',
    FirmwareUpdateRole: '',
    Tags: [{Key: '', Value: ''}],
    RedundancyPercent: 0,
    FragmentSizeBytes: 0,
    FragmentIntervalMS: 0
  }
};

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

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

const url = '{{baseUrl}}/fuota-tasks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","ClientRequestToken":"","LoRaWAN":{"RfRegion":""},"FirmwareUpdateImage":"","FirmwareUpdateRole":"","Tags":[{"Key":"","Value":""}],"RedundancyPercent":0,"FragmentSizeBytes":0,"FragmentIntervalMS":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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"ClientRequestToken": @"",
                              @"LoRaWAN": @{ @"RfRegion": @"" },
                              @"FirmwareUpdateImage": @"",
                              @"FirmwareUpdateRole": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"RedundancyPercent": @0,
                              @"FragmentSizeBytes": @0,
                              @"FragmentIntervalMS": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/fuota-tasks"]
                                                       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}}/fuota-tasks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}" in

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

 "{{baseUrl}}/fuota-tasks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'ClientRequestToken' => '',
    'LoRaWAN' => [
        'RfRegion' => ''
    ],
    'FirmwareUpdateImage' => '',
    'FirmwareUpdateRole' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'RedundancyPercent' => 0,
    'FragmentSizeBytes' => 0,
    'FragmentIntervalMS' => 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}}/fuota-tasks', [
  'body' => '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'ClientRequestToken' => '',
  'LoRaWAN' => [
    'RfRegion' => ''
  ],
  'FirmwareUpdateImage' => '',
  'FirmwareUpdateRole' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'RedundancyPercent' => 0,
  'FragmentSizeBytes' => 0,
  'FragmentIntervalMS' => 0
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'ClientRequestToken' => '',
  'LoRaWAN' => [
    'RfRegion' => ''
  ],
  'FirmwareUpdateImage' => '',
  'FirmwareUpdateRole' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'RedundancyPercent' => 0,
  'FragmentSizeBytes' => 0,
  'FragmentIntervalMS' => 0
]));
$request->setRequestUrl('{{baseUrl}}/fuota-tasks');
$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}}/fuota-tasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}"

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

conn.request("POST", "/baseUrl/fuota-tasks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/fuota-tasks"

payload = {
    "Name": "",
    "Description": "",
    "ClientRequestToken": "",
    "LoRaWAN": { "RfRegion": "" },
    "FirmwareUpdateImage": "",
    "FirmwareUpdateRole": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "RedundancyPercent": 0,
    "FragmentSizeBytes": 0,
    "FragmentIntervalMS": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 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}}/fuota-tasks")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 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/fuota-tasks') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "ClientRequestToken": "",
        "LoRaWAN": json!({"RfRegion": ""}),
        "FirmwareUpdateImage": "",
        "FirmwareUpdateRole": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "RedundancyPercent": 0,
        "FragmentSizeBytes": 0,
        "FragmentIntervalMS": 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);
}

echo '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}' |  \
  http POST {{baseUrl}}/fuota-tasks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "ClientRequestToken": "",\n  "LoRaWAN": {\n    "RfRegion": ""\n  },\n  "FirmwareUpdateImage": "",\n  "FirmwareUpdateRole": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "RedundancyPercent": 0,\n  "FragmentSizeBytes": 0,\n  "FragmentIntervalMS": 0\n}' \
  --output-document \
  - {{baseUrl}}/fuota-tasks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": ["RfRegion": ""],
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/multicast-groups" {:content-type :json
                                                             :form-params {:Name ""
                                                                           :Description ""
                                                                           :ClientRequestToken ""
                                                                           :LoRaWAN {:RfRegion ""
                                                                                     :DlClass ""}
                                                                           :Tags [{:Key ""
                                                                                   :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/multicast-groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/multicast-groups"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/multicast-groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/multicast-groups"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/multicast-groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 187

{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/multicast-groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/multicast-groups")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  ClientRequestToken: '',
  LoRaWAN: {
    RfRegion: '',
    DlClass: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/multicast-groups',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    ClientRequestToken: '',
    LoRaWAN: {RfRegion: '', DlClass: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/multicast-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","ClientRequestToken":"","LoRaWAN":{"RfRegion":"","DlClass":""},"Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/multicast-groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "ClientRequestToken": "",\n  "LoRaWAN": {\n    "RfRegion": "",\n    "DlClass": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/multicast-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/multicast-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({
  Name: '',
  Description: '',
  ClientRequestToken: '',
  LoRaWAN: {RfRegion: '', DlClass: ''},
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/multicast-groups',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    ClientRequestToken: '',
    LoRaWAN: {RfRegion: '', DlClass: ''},
    Tags: [{Key: '', Value: ''}]
  },
  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}}/multicast-groups');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  ClientRequestToken: '',
  LoRaWAN: {
    RfRegion: '',
    DlClass: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/multicast-groups',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    ClientRequestToken: '',
    LoRaWAN: {RfRegion: '', DlClass: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/multicast-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","ClientRequestToken":"","LoRaWAN":{"RfRegion":"","DlClass":""},"Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Description": @"",
                              @"ClientRequestToken": @"",
                              @"LoRaWAN": @{ @"RfRegion": @"", @"DlClass": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/multicast-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}}/multicast-groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/multicast-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([
    'Name' => '',
    'Description' => '',
    'ClientRequestToken' => '',
    'LoRaWAN' => [
        'RfRegion' => '',
        'DlClass' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/multicast-groups', [
  'body' => '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'ClientRequestToken' => '',
  'LoRaWAN' => [
    'RfRegion' => '',
    'DlClass' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'ClientRequestToken' => '',
  'LoRaWAN' => [
    'RfRegion' => '',
    'DlClass' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/multicast-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}}/multicast-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/multicast-groups", payload, headers)

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

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

import requests

url = "{{baseUrl}}/multicast-groups"

payload = {
    "Name": "",
    "Description": "",
    "ClientRequestToken": "",
    "LoRaWAN": {
        "RfRegion": "",
        "DlClass": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/multicast-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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/multicast-groups') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "ClientRequestToken": "",
        "LoRaWAN": json!({
            "RfRegion": "",
            "DlClass": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/multicast-groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "ClientRequestToken": "",\n  "LoRaWAN": {\n    "RfRegion": "",\n    "DlClass": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": [
    "RfRegion": "",
    "DlClass": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/network-analyzer-configurations");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/network-analyzer-configurations" {:content-type :json
                                                                            :form-params {:Name ""
                                                                                          :TraceContent {:WirelessDeviceFrameInfo ""
                                                                                                         :LogLevel ""}
                                                                                          :WirelessDevices []
                                                                                          :WirelessGateways []
                                                                                          :Description ""
                                                                                          :Tags [{:Key ""
                                                                                                  :Value ""}]
                                                                                          :ClientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/network-analyzer-configurations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/network-analyzer-configurations"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/network-analyzer-configurations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/network-analyzer-configurations"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/network-analyzer-configurations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 259

{
  "Name": "",
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/network-analyzer-configurations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/network-analyzer-configurations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/network-analyzer-configurations")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  TraceContent: {
    WirelessDeviceFrameInfo: '',
    LogLevel: ''
  },
  WirelessDevices: [],
  WirelessGateways: [],
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/network-analyzer-configurations',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
    WirelessDevices: [],
    WirelessGateways: [],
    Description: '',
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/network-analyzer-configurations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","TraceContent":{"WirelessDeviceFrameInfo":"","LogLevel":""},"WirelessDevices":[],"WirelessGateways":[],"Description":"","Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/network-analyzer-configurations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "TraceContent": {\n    "WirelessDeviceFrameInfo": "",\n    "LogLevel": ""\n  },\n  "WirelessDevices": [],\n  "WirelessGateways": [],\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations")
  .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/network-analyzer-configurations',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
  WirelessDevices: [],
  WirelessGateways: [],
  Description: '',
  Tags: [{Key: '', Value: ''}],
  ClientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/network-analyzer-configurations',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
    WirelessDevices: [],
    WirelessGateways: [],
    Description: '',
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  },
  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}}/network-analyzer-configurations');

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

req.type('json');
req.send({
  Name: '',
  TraceContent: {
    WirelessDeviceFrameInfo: '',
    LogLevel: ''
  },
  WirelessDevices: [],
  WirelessGateways: [],
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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}}/network-analyzer-configurations',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
    WirelessDevices: [],
    WirelessGateways: [],
    Description: '',
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/network-analyzer-configurations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","TraceContent":{"WirelessDeviceFrameInfo":"","LogLevel":""},"WirelessDevices":[],"WirelessGateways":[],"Description":"","Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"TraceContent": @{ @"WirelessDeviceFrameInfo": @"", @"LogLevel": @"" },
                              @"WirelessDevices": @[  ],
                              @"WirelessGateways": @[  ],
                              @"Description": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/network-analyzer-configurations"]
                                                       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}}/network-analyzer-configurations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/network-analyzer-configurations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'TraceContent' => [
        'WirelessDeviceFrameInfo' => '',
        'LogLevel' => ''
    ],
    'WirelessDevices' => [
        
    ],
    'WirelessGateways' => [
        
    ],
    'Description' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientRequestToken' => ''
  ]),
  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}}/network-analyzer-configurations', [
  'body' => '{
  "Name": "",
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/network-analyzer-configurations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'TraceContent' => [
    'WirelessDeviceFrameInfo' => '',
    'LogLevel' => ''
  ],
  'WirelessDevices' => [
    
  ],
  'WirelessGateways' => [
    
  ],
  'Description' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'TraceContent' => [
    'WirelessDeviceFrameInfo' => '',
    'LogLevel' => ''
  ],
  'WirelessDevices' => [
    
  ],
  'WirelessGateways' => [
    
  ],
  'Description' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/network-analyzer-configurations');
$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}}/network-analyzer-configurations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/network-analyzer-configurations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/network-analyzer-configurations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/network-analyzer-configurations"

payload = {
    "Name": "",
    "TraceContent": {
        "WirelessDeviceFrameInfo": "",
        "LogLevel": ""
    },
    "WirelessDevices": [],
    "WirelessGateways": [],
    "Description": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/network-analyzer-configurations"

payload <- "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/network-analyzer-configurations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/network-analyzer-configurations') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevices\": [],\n  \"WirelessGateways\": [],\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "TraceContent": json!({
            "WirelessDeviceFrameInfo": "",
            "LogLevel": ""
        }),
        "WirelessDevices": (),
        "WirelessGateways": (),
        "Description": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/network-analyzer-configurations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "TraceContent": {\n    "WirelessDeviceFrameInfo": "",\n    "LogLevel": ""\n  },\n  "WirelessDevices": [],\n  "WirelessGateways": [],\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/network-analyzer-configurations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "TraceContent": [
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  ],
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/service-profiles" {:content-type :json
                                                             :form-params {:Name ""
                                                                           :LoRaWAN {:AddGwMetadata ""
                                                                                     :DrMin ""
                                                                                     :DrMax ""
                                                                                     :PrAllowed ""
                                                                                     :RaAllowed ""}
                                                                           :Tags [{:Key ""
                                                                                   :Value ""}]
                                                                           :ClientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/service-profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/service-profiles"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/service-profiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/service-profiles"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/service-profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 228

{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/service-profiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/service-profiles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/service-profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/service-profiles")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  LoRaWAN: {
    AddGwMetadata: '',
    DrMin: '',
    DrMax: '',
    PrAllowed: '',
    RaAllowed: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/service-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    LoRaWAN: {AddGwMetadata: '', DrMin: '', DrMax: '', PrAllowed: '', RaAllowed: ''},
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/service-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","LoRaWAN":{"AddGwMetadata":"","DrMin":"","DrMax":"","PrAllowed":"","RaAllowed":""},"Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/service-profiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "LoRaWAN": {\n    "AddGwMetadata": "",\n    "DrMin": "",\n    "DrMax": "",\n    "PrAllowed": "",\n    "RaAllowed": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/service-profiles")
  .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/service-profiles',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  LoRaWAN: {AddGwMetadata: '', DrMin: '', DrMax: '', PrAllowed: '', RaAllowed: ''},
  Tags: [{Key: '', Value: ''}],
  ClientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/service-profiles',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    LoRaWAN: {AddGwMetadata: '', DrMin: '', DrMax: '', PrAllowed: '', RaAllowed: ''},
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  },
  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}}/service-profiles');

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

req.type('json');
req.send({
  Name: '',
  LoRaWAN: {
    AddGwMetadata: '',
    DrMin: '',
    DrMax: '',
    PrAllowed: '',
    RaAllowed: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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}}/service-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    LoRaWAN: {AddGwMetadata: '', DrMin: '', DrMax: '', PrAllowed: '', RaAllowed: ''},
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/service-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","LoRaWAN":{"AddGwMetadata":"","DrMin":"","DrMax":"","PrAllowed":"","RaAllowed":""},"Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"LoRaWAN": @{ @"AddGwMetadata": @"", @"DrMin": @"", @"DrMax": @"", @"PrAllowed": @"", @"RaAllowed": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/service-profiles"]
                                                       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}}/service-profiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/service-profiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'LoRaWAN' => [
        'AddGwMetadata' => '',
        'DrMin' => '',
        'DrMax' => '',
        'PrAllowed' => '',
        'RaAllowed' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientRequestToken' => ''
  ]),
  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}}/service-profiles', [
  'body' => '{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'LoRaWAN' => [
    'AddGwMetadata' => '',
    'DrMin' => '',
    'DrMax' => '',
    'PrAllowed' => '',
    'RaAllowed' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'LoRaWAN' => [
    'AddGwMetadata' => '',
    'DrMin' => '',
    'DrMax' => '',
    'PrAllowed' => '',
    'RaAllowed' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/service-profiles');
$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}}/service-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/service-profiles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/service-profiles"

payload = {
    "Name": "",
    "LoRaWAN": {
        "AddGwMetadata": "",
        "DrMin": "",
        "DrMax": "",
        "PrAllowed": "",
        "RaAllowed": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/service-profiles"

payload <- "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/service-profiles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/service-profiles') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"LoRaWAN\": {\n    \"AddGwMetadata\": \"\",\n    \"DrMin\": \"\",\n    \"DrMax\": \"\",\n    \"PrAllowed\": \"\",\n    \"RaAllowed\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "LoRaWAN": json!({
            "AddGwMetadata": "",
            "DrMin": "",
            "DrMax": "",
            "PrAllowed": "",
            "RaAllowed": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/service-profiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "LoRaWAN": {\n    "AddGwMetadata": "",\n    "DrMin": "",\n    "DrMax": "",\n    "PrAllowed": "",\n    "RaAllowed": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/service-profiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "LoRaWAN": [
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-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  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/wireless-devices" {:content-type :json
                                                             :form-params {:Type ""
                                                                           :Name ""
                                                                           :Description ""
                                                                           :DestinationName ""
                                                                           :ClientRequestToken ""
                                                                           :LoRaWAN {:DevEui ""
                                                                                     :DeviceProfileId ""
                                                                                     :ServiceProfileId ""
                                                                                     :OtaaV1_1 ""
                                                                                     :OtaaV1_0_x ""
                                                                                     :AbpV1_1 ""
                                                                                     :AbpV1_0_x ""
                                                                                     :FPorts {:Fuota 0
                                                                                              :Multicast 0
                                                                                              :ClockSync 0
                                                                                              :Positioning ""
                                                                                              :Applications ""}}
                                                                           :Tags [{:Key ""
                                                                                   :Value ""}]
                                                                           :Positioning ""
                                                                           :Sidewalk {:DeviceProfileId ""}}})

require "http/client"

url = "{{baseUrl}}/wireless-devices"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/wireless-devices"),
    Content = new StringContent("{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-devices");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless-devices"

	payload := strings.NewReader("{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/wireless-devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 545

{
  "Type": "",
  "Name": "",
  "Description": "",
  "DestinationName": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "DevEui": "",
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "OtaaV1_1": "",
    "OtaaV1_0_x": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": {
      "Fuota": 0,
      "Multicast": 0,
      "ClockSync": 0,
      "Positioning": "",
      "Applications": ""
    }
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Positioning": "",
  "Sidewalk": {
    "DeviceProfileId": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless-devices")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/wireless-devices")
  .header("content-type", "application/json")
  .body("{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Type: '',
  Name: '',
  Description: '',
  DestinationName: '',
  ClientRequestToken: '',
  LoRaWAN: {
    DevEui: '',
    DeviceProfileId: '',
    ServiceProfileId: '',
    OtaaV1_1: '',
    OtaaV1_0_x: '',
    AbpV1_1: '',
    AbpV1_0_x: '',
    FPorts: {
      Fuota: 0,
      Multicast: 0,
      ClockSync: 0,
      Positioning: '',
      Applications: ''
    }
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Positioning: '',
  Sidewalk: {
    DeviceProfileId: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-devices',
  headers: {'content-type': 'application/json'},
  data: {
    Type: '',
    Name: '',
    Description: '',
    DestinationName: '',
    ClientRequestToken: '',
    LoRaWAN: {
      DevEui: '',
      DeviceProfileId: '',
      ServiceProfileId: '',
      OtaaV1_1: '',
      OtaaV1_0_x: '',
      AbpV1_1: '',
      AbpV1_0_x: '',
      FPorts: {Fuota: 0, Multicast: 0, ClockSync: 0, Positioning: '', Applications: ''}
    },
    Tags: [{Key: '', Value: ''}],
    Positioning: '',
    Sidewalk: {DeviceProfileId: ''}
  }
};

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

const url = '{{baseUrl}}/wireless-devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Type":"","Name":"","Description":"","DestinationName":"","ClientRequestToken":"","LoRaWAN":{"DevEui":"","DeviceProfileId":"","ServiceProfileId":"","OtaaV1_1":"","OtaaV1_0_x":"","AbpV1_1":"","AbpV1_0_x":"","FPorts":{"Fuota":0,"Multicast":0,"ClockSync":0,"Positioning":"","Applications":""}},"Tags":[{"Key":"","Value":""}],"Positioning":"","Sidewalk":{"DeviceProfileId":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Type": "",\n  "Name": "",\n  "Description": "",\n  "DestinationName": "",\n  "ClientRequestToken": "",\n  "LoRaWAN": {\n    "DevEui": "",\n    "DeviceProfileId": "",\n    "ServiceProfileId": "",\n    "OtaaV1_1": "",\n    "OtaaV1_0_x": "",\n    "AbpV1_1": "",\n    "AbpV1_0_x": "",\n    "FPorts": {\n      "Fuota": 0,\n      "Multicast": 0,\n      "ClockSync": 0,\n      "Positioning": "",\n      "Applications": ""\n    }\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Positioning": "",\n  "Sidewalk": {\n    "DeviceProfileId": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless-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/wireless-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({
  Type: '',
  Name: '',
  Description: '',
  DestinationName: '',
  ClientRequestToken: '',
  LoRaWAN: {
    DevEui: '',
    DeviceProfileId: '',
    ServiceProfileId: '',
    OtaaV1_1: '',
    OtaaV1_0_x: '',
    AbpV1_1: '',
    AbpV1_0_x: '',
    FPorts: {Fuota: 0, Multicast: 0, ClockSync: 0, Positioning: '', Applications: ''}
  },
  Tags: [{Key: '', Value: ''}],
  Positioning: '',
  Sidewalk: {DeviceProfileId: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-devices',
  headers: {'content-type': 'application/json'},
  body: {
    Type: '',
    Name: '',
    Description: '',
    DestinationName: '',
    ClientRequestToken: '',
    LoRaWAN: {
      DevEui: '',
      DeviceProfileId: '',
      ServiceProfileId: '',
      OtaaV1_1: '',
      OtaaV1_0_x: '',
      AbpV1_1: '',
      AbpV1_0_x: '',
      FPorts: {Fuota: 0, Multicast: 0, ClockSync: 0, Positioning: '', Applications: ''}
    },
    Tags: [{Key: '', Value: ''}],
    Positioning: '',
    Sidewalk: {DeviceProfileId: ''}
  },
  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}}/wireless-devices');

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

req.type('json');
req.send({
  Type: '',
  Name: '',
  Description: '',
  DestinationName: '',
  ClientRequestToken: '',
  LoRaWAN: {
    DevEui: '',
    DeviceProfileId: '',
    ServiceProfileId: '',
    OtaaV1_1: '',
    OtaaV1_0_x: '',
    AbpV1_1: '',
    AbpV1_0_x: '',
    FPorts: {
      Fuota: 0,
      Multicast: 0,
      ClockSync: 0,
      Positioning: '',
      Applications: ''
    }
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Positioning: '',
  Sidewalk: {
    DeviceProfileId: ''
  }
});

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}}/wireless-devices',
  headers: {'content-type': 'application/json'},
  data: {
    Type: '',
    Name: '',
    Description: '',
    DestinationName: '',
    ClientRequestToken: '',
    LoRaWAN: {
      DevEui: '',
      DeviceProfileId: '',
      ServiceProfileId: '',
      OtaaV1_1: '',
      OtaaV1_0_x: '',
      AbpV1_1: '',
      AbpV1_0_x: '',
      FPorts: {Fuota: 0, Multicast: 0, ClockSync: 0, Positioning: '', Applications: ''}
    },
    Tags: [{Key: '', Value: ''}],
    Positioning: '',
    Sidewalk: {DeviceProfileId: ''}
  }
};

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

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

const url = '{{baseUrl}}/wireless-devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Type":"","Name":"","Description":"","DestinationName":"","ClientRequestToken":"","LoRaWAN":{"DevEui":"","DeviceProfileId":"","ServiceProfileId":"","OtaaV1_1":"","OtaaV1_0_x":"","AbpV1_1":"","AbpV1_0_x":"","FPorts":{"Fuota":0,"Multicast":0,"ClockSync":0,"Positioning":"","Applications":""}},"Tags":[{"Key":"","Value":""}],"Positioning":"","Sidewalk":{"DeviceProfileId":""}}'
};

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 = @{ @"Type": @"",
                              @"Name": @"",
                              @"Description": @"",
                              @"DestinationName": @"",
                              @"ClientRequestToken": @"",
                              @"LoRaWAN": @{ @"DevEui": @"", @"DeviceProfileId": @"", @"ServiceProfileId": @"", @"OtaaV1_1": @"", @"OtaaV1_0_x": @"", @"AbpV1_1": @"", @"AbpV1_0_x": @"", @"FPorts": @{ @"Fuota": @0, @"Multicast": @0, @"ClockSync": @0, @"Positioning": @"", @"Applications": @"" } },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"Positioning": @"",
                              @"Sidewalk": @{ @"DeviceProfileId": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-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}}/wireless-devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/wireless-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([
    'Type' => '',
    'Name' => '',
    'Description' => '',
    'DestinationName' => '',
    'ClientRequestToken' => '',
    'LoRaWAN' => [
        'DevEui' => '',
        'DeviceProfileId' => '',
        'ServiceProfileId' => '',
        'OtaaV1_1' => '',
        'OtaaV1_0_x' => '',
        'AbpV1_1' => '',
        'AbpV1_0_x' => '',
        'FPorts' => [
                'Fuota' => 0,
                'Multicast' => 0,
                'ClockSync' => 0,
                'Positioning' => '',
                'Applications' => ''
        ]
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'Positioning' => '',
    'Sidewalk' => [
        'DeviceProfileId' => ''
    ]
  ]),
  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}}/wireless-devices', [
  'body' => '{
  "Type": "",
  "Name": "",
  "Description": "",
  "DestinationName": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "DevEui": "",
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "OtaaV1_1": "",
    "OtaaV1_0_x": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": {
      "Fuota": 0,
      "Multicast": 0,
      "ClockSync": 0,
      "Positioning": "",
      "Applications": ""
    }
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Positioning": "",
  "Sidewalk": {
    "DeviceProfileId": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Type' => '',
  'Name' => '',
  'Description' => '',
  'DestinationName' => '',
  'ClientRequestToken' => '',
  'LoRaWAN' => [
    'DevEui' => '',
    'DeviceProfileId' => '',
    'ServiceProfileId' => '',
    'OtaaV1_1' => '',
    'OtaaV1_0_x' => '',
    'AbpV1_1' => '',
    'AbpV1_0_x' => '',
    'FPorts' => [
        'Fuota' => 0,
        'Multicast' => 0,
        'ClockSync' => 0,
        'Positioning' => '',
        'Applications' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Positioning' => '',
  'Sidewalk' => [
    'DeviceProfileId' => ''
  ]
]));

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

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

append(json_encode([
  'Type' => '',
  'Name' => '',
  'Description' => '',
  'DestinationName' => '',
  'ClientRequestToken' => '',
  'LoRaWAN' => [
    'DevEui' => '',
    'DeviceProfileId' => '',
    'ServiceProfileId' => '',
    'OtaaV1_1' => '',
    'OtaaV1_0_x' => '',
    'AbpV1_1' => '',
    'AbpV1_0_x' => '',
    'FPorts' => [
        'Fuota' => 0,
        'Multicast' => 0,
        'ClockSync' => 0,
        'Positioning' => '',
        'Applications' => ''
    ]
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Positioning' => '',
  'Sidewalk' => [
    'DeviceProfileId' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/wireless-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}}/wireless-devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Type": "",
  "Name": "",
  "Description": "",
  "DestinationName": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "DevEui": "",
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "OtaaV1_1": "",
    "OtaaV1_0_x": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": {
      "Fuota": 0,
      "Multicast": 0,
      "ClockSync": 0,
      "Positioning": "",
      "Applications": ""
    }
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Positioning": "",
  "Sidewalk": {
    "DeviceProfileId": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Type": "",
  "Name": "",
  "Description": "",
  "DestinationName": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "DevEui": "",
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "OtaaV1_1": "",
    "OtaaV1_0_x": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": {
      "Fuota": 0,
      "Multicast": 0,
      "ClockSync": 0,
      "Positioning": "",
      "Applications": ""
    }
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Positioning": "",
  "Sidewalk": {
    "DeviceProfileId": ""
  }
}'

import http.client

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

payload = "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/wireless-devices", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-devices"

payload = {
    "Type": "",
    "Name": "",
    "Description": "",
    "DestinationName": "",
    "ClientRequestToken": "",
    "LoRaWAN": {
        "DevEui": "",
        "DeviceProfileId": "",
        "ServiceProfileId": "",
        "OtaaV1_1": "",
        "OtaaV1_0_x": "",
        "AbpV1_1": "",
        "AbpV1_0_x": "",
        "FPorts": {
            "Fuota": 0,
            "Multicast": 0,
            "ClockSync": 0,
            "Positioning": "",
            "Applications": ""
        }
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "Positioning": "",
    "Sidewalk": { "DeviceProfileId": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices"

payload <- "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-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  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/wireless-devices') do |req|
  req.body = "{\n  \"Type\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"LoRaWAN\": {\n    \"DevEui\": \"\",\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"OtaaV1_1\": \"\",\n    \"OtaaV1_0_x\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": {\n      \"Fuota\": 0,\n      \"Multicast\": 0,\n      \"ClockSync\": 0,\n      \"Positioning\": \"\",\n      \"Applications\": \"\"\n    }\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Positioning\": \"\",\n  \"Sidewalk\": {\n    \"DeviceProfileId\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Type": "",
        "Name": "",
        "Description": "",
        "DestinationName": "",
        "ClientRequestToken": "",
        "LoRaWAN": json!({
            "DevEui": "",
            "DeviceProfileId": "",
            "ServiceProfileId": "",
            "OtaaV1_1": "",
            "OtaaV1_0_x": "",
            "AbpV1_1": "",
            "AbpV1_0_x": "",
            "FPorts": json!({
                "Fuota": 0,
                "Multicast": 0,
                "ClockSync": 0,
                "Positioning": "",
                "Applications": ""
            })
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "Positioning": "",
        "Sidewalk": json!({"DeviceProfileId": ""})
    });

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

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

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

    dbg!(results);
}

echo '{
  "Type": "",
  "Name": "",
  "Description": "",
  "DestinationName": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "DevEui": "",
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "OtaaV1_1": "",
    "OtaaV1_0_x": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": {
      "Fuota": 0,
      "Multicast": 0,
      "ClockSync": 0,
      "Positioning": "",
      "Applications": ""
    }
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Positioning": "",
  "Sidewalk": {
    "DeviceProfileId": ""
  }
}' |  \
  http POST {{baseUrl}}/wireless-devices \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Type": "",\n  "Name": "",\n  "Description": "",\n  "DestinationName": "",\n  "ClientRequestToken": "",\n  "LoRaWAN": {\n    "DevEui": "",\n    "DeviceProfileId": "",\n    "ServiceProfileId": "",\n    "OtaaV1_1": "",\n    "OtaaV1_0_x": "",\n    "AbpV1_1": "",\n    "AbpV1_0_x": "",\n    "FPorts": {\n      "Fuota": 0,\n      "Multicast": 0,\n      "ClockSync": 0,\n      "Positioning": "",\n      "Applications": ""\n    }\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Positioning": "",\n  "Sidewalk": {\n    "DeviceProfileId": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/wireless-devices

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Type": "",
  "Name": "",
  "Description": "",
  "DestinationName": "",
  "ClientRequestToken": "",
  "LoRaWAN": [
    "DevEui": "",
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "OtaaV1_1": "",
    "OtaaV1_0_x": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": [
      "Fuota": 0,
      "Multicast": 0,
      "ClockSync": 0,
      "Positioning": "",
      "Applications": ""
    ]
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "Positioning": "",
  "Sidewalk": ["DeviceProfileId": ""]
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/wireless-gateways" {:content-type :json
                                                              :form-params {:Name ""
                                                                            :Description ""
                                                                            :LoRaWAN {:GatewayEui ""
                                                                                      :RfRegion ""
                                                                                      :JoinEuiFilters []
                                                                                      :NetIdFilters []
                                                                                      :SubBands []
                                                                                      :Beaconing ""
                                                                                      :MaxEirp ""}
                                                                            :Tags [{:Key ""
                                                                                    :Value ""}]
                                                                            :ClientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/wireless-gateways"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/wireless-gateways"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/wireless-gateways");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateways"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/wireless-gateways HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 300

{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless-gateways")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-gateways")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/wireless-gateways")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  LoRaWAN: {
    GatewayEui: '',
    RfRegion: '',
    JoinEuiFilters: [],
    NetIdFilters: [],
    SubBands: [],
    Beaconing: '',
    MaxEirp: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-gateways',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    LoRaWAN: {
      GatewayEui: '',
      RfRegion: '',
      JoinEuiFilters: [],
      NetIdFilters: [],
      SubBands: [],
      Beaconing: '',
      MaxEirp: ''
    },
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/wireless-gateways';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LoRaWAN":{"GatewayEui":"","RfRegion":"","JoinEuiFilters":[],"NetIdFilters":[],"SubBands":[],"Beaconing":"","MaxEirp":""},"Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-gateways',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "GatewayEui": "",\n    "RfRegion": "",\n    "JoinEuiFilters": [],\n    "NetIdFilters": [],\n    "SubBands": [],\n    "Beaconing": "",\n    "MaxEirp": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways")
  .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/wireless-gateways',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  Description: '',
  LoRaWAN: {
    GatewayEui: '',
    RfRegion: '',
    JoinEuiFilters: [],
    NetIdFilters: [],
    SubBands: [],
    Beaconing: '',
    MaxEirp: ''
  },
  Tags: [{Key: '', Value: ''}],
  ClientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-gateways',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    LoRaWAN: {
      GatewayEui: '',
      RfRegion: '',
      JoinEuiFilters: [],
      NetIdFilters: [],
      SubBands: [],
      Beaconing: '',
      MaxEirp: ''
    },
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  },
  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}}/wireless-gateways');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  LoRaWAN: {
    GatewayEui: '',
    RfRegion: '',
    JoinEuiFilters: [],
    NetIdFilters: [],
    SubBands: [],
    Beaconing: '',
    MaxEirp: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientRequestToken: ''
});

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}}/wireless-gateways',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    LoRaWAN: {
      GatewayEui: '',
      RfRegion: '',
      JoinEuiFilters: [],
      NetIdFilters: [],
      SubBands: [],
      Beaconing: '',
      MaxEirp: ''
    },
    Tags: [{Key: '', Value: ''}],
    ClientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/wireless-gateways';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LoRaWAN":{"GatewayEui":"","RfRegion":"","JoinEuiFilters":[],"NetIdFilters":[],"SubBands":[],"Beaconing":"","MaxEirp":""},"Tags":[{"Key":"","Value":""}],"ClientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Description": @"",
                              @"LoRaWAN": @{ @"GatewayEui": @"", @"RfRegion": @"", @"JoinEuiFilters": @[  ], @"NetIdFilters": @[  ], @"SubBands": @[  ], @"Beaconing": @"", @"MaxEirp": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-gateways"]
                                                       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}}/wireless-gateways" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/wireless-gateways",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'LoRaWAN' => [
        'GatewayEui' => '',
        'RfRegion' => '',
        'JoinEuiFilters' => [
                
        ],
        'NetIdFilters' => [
                
        ],
        'SubBands' => [
                
        ],
        'Beaconing' => '',
        'MaxEirp' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientRequestToken' => ''
  ]),
  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}}/wireless-gateways', [
  'body' => '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'GatewayEui' => '',
    'RfRegion' => '',
    'JoinEuiFilters' => [
        
    ],
    'NetIdFilters' => [
        
    ],
    'SubBands' => [
        
    ],
    'Beaconing' => '',
    'MaxEirp' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'GatewayEui' => '',
    'RfRegion' => '',
    'JoinEuiFilters' => [
        
    ],
    'NetIdFilters' => [
        
    ],
    'SubBands' => [
        
    ],
    'Beaconing' => '',
    'MaxEirp' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/wireless-gateways');
$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}}/wireless-gateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/wireless-gateways", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-gateways"

payload = {
    "Name": "",
    "Description": "",
    "LoRaWAN": {
        "GatewayEui": "",
        "RfRegion": "",
        "JoinEuiFilters": [],
        "NetIdFilters": [],
        "SubBands": [],
        "Beaconing": "",
        "MaxEirp": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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}}/wireless-gateways")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\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/wireless-gateways') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"GatewayEui\": \"\",\n    \"RfRegion\": \"\",\n    \"JoinEuiFilters\": [],\n    \"NetIdFilters\": [],\n    \"SubBands\": [],\n    \"Beaconing\": \"\",\n    \"MaxEirp\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "LoRaWAN": json!({
            "GatewayEui": "",
            "RfRegion": "",
            "JoinEuiFilters": (),
            "NetIdFilters": (),
            "SubBands": (),
            "Beaconing": "",
            "MaxEirp": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/wireless-gateways \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "GatewayEui": "",\n    "RfRegion": "",\n    "JoinEuiFilters": [],\n    "NetIdFilters": [],\n    "SubBands": [],\n    "Beaconing": "",\n    "MaxEirp": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-gateways

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "LoRaWAN": [
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/tasks");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/wireless-gateways/:Id/tasks" {:content-type :json
                                                                        :form-params {:WirelessGatewayTaskDefinitionId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id/tasks"

	payload := strings.NewReader("{\n  \"WirelessGatewayTaskDefinitionId\": \"\"\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/wireless-gateways/:Id/tasks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "WirelessGatewayTaskDefinitionId": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/wireless-gateways/:Id/tasks")
  .header("content-type", "application/json")
  .body("{\n  \"WirelessGatewayTaskDefinitionId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/wireless-gateways/:Id/tasks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-gateways/:Id/tasks',
  headers: {'content-type': 'application/json'},
  data: {WirelessGatewayTaskDefinitionId: ''}
};

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

const url = '{{baseUrl}}/wireless-gateways/:Id/tasks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WirelessGatewayTaskDefinitionId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-gateways/:Id/tasks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WirelessGatewayTaskDefinitionId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-gateways/:Id/tasks',
  headers: {'content-type': 'application/json'},
  body: {WirelessGatewayTaskDefinitionId: ''},
  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}}/wireless-gateways/:Id/tasks');

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

req.type('json');
req.send({
  WirelessGatewayTaskDefinitionId: ''
});

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}}/wireless-gateways/:Id/tasks',
  headers: {'content-type': 'application/json'},
  data: {WirelessGatewayTaskDefinitionId: ''}
};

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

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

const url = '{{baseUrl}}/wireless-gateways/:Id/tasks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WirelessGatewayTaskDefinitionId":""}'
};

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

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

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

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

 "{{baseUrl}}/wireless-gateways/:Id/tasks",
  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([
    'WirelessGatewayTaskDefinitionId' => ''
  ]),
  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}}/wireless-gateways/:Id/tasks', [
  'body' => '{
  "WirelessGatewayTaskDefinitionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/tasks');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/tasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WirelessGatewayTaskDefinitionId": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/wireless-gateways/:Id/tasks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-gateways/:Id/tasks"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id/tasks"

payload <- "{\n  \"WirelessGatewayTaskDefinitionId\": \"\"\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}}/wireless-gateways/:Id/tasks")

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  \"WirelessGatewayTaskDefinitionId\": \"\"\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/wireless-gateways/:Id/tasks') do |req|
  req.body = "{\n  \"WirelessGatewayTaskDefinitionId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/tasks";

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

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

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

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

    dbg!(results);
}

echo '{
  "WirelessGatewayTaskDefinitionId": ""
}' |  \
  http POST {{baseUrl}}/wireless-gateways/:Id/tasks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "WirelessGatewayTaskDefinitionId": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/tasks

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateway-task-definitions");

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  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/wireless-gateway-task-definitions" {:content-type :json
                                                                              :form-params {:AutoCreateTasks false
                                                                                            :Name ""
                                                                                            :Update {:UpdateDataSource ""
                                                                                                     :UpdateDataRole ""
                                                                                                     :LoRaWAN ""}
                                                                                            :ClientRequestToken ""
                                                                                            :Tags [{:Key ""
                                                                                                    :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/wireless-gateway-task-definitions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/wireless-gateway-task-definitions"),
    Content = new StringContent("{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-gateway-task-definitions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateway-task-definitions"

	payload := strings.NewReader("{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/wireless-gateway-task-definitions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 227

{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless-gateway-task-definitions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateway-task-definitions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-gateway-task-definitions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/wireless-gateway-task-definitions")
  .header("content-type", "application/json")
  .body("{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  AutoCreateTasks: false,
  Name: '',
  Update: {
    UpdateDataSource: '',
    UpdateDataRole: '',
    LoRaWAN: ''
  },
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/wireless-gateway-task-definitions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-gateway-task-definitions',
  headers: {'content-type': 'application/json'},
  data: {
    AutoCreateTasks: false,
    Name: '',
    Update: {UpdateDataSource: '', UpdateDataRole: '', LoRaWAN: ''},
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/wireless-gateway-task-definitions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AutoCreateTasks":false,"Name":"","Update":{"UpdateDataSource":"","UpdateDataRole":"","LoRaWAN":""},"ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-gateway-task-definitions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AutoCreateTasks": false,\n  "Name": "",\n  "Update": {\n    "UpdateDataSource": "",\n    "UpdateDataRole": "",\n    "LoRaWAN": ""\n  },\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateway-task-definitions")
  .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/wireless-gateway-task-definitions',
  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({
  AutoCreateTasks: false,
  Name: '',
  Update: {UpdateDataSource: '', UpdateDataRole: '', LoRaWAN: ''},
  ClientRequestToken: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-gateway-task-definitions',
  headers: {'content-type': 'application/json'},
  body: {
    AutoCreateTasks: false,
    Name: '',
    Update: {UpdateDataSource: '', UpdateDataRole: '', LoRaWAN: ''},
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  },
  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}}/wireless-gateway-task-definitions');

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

req.type('json');
req.send({
  AutoCreateTasks: false,
  Name: '',
  Update: {
    UpdateDataSource: '',
    UpdateDataRole: '',
    LoRaWAN: ''
  },
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/wireless-gateway-task-definitions',
  headers: {'content-type': 'application/json'},
  data: {
    AutoCreateTasks: false,
    Name: '',
    Update: {UpdateDataSource: '', UpdateDataRole: '', LoRaWAN: ''},
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/wireless-gateway-task-definitions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AutoCreateTasks":false,"Name":"","Update":{"UpdateDataSource":"","UpdateDataRole":"","LoRaWAN":""},"ClientRequestToken":"","Tags":[{"Key":"","Value":""}]}'
};

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 = @{ @"AutoCreateTasks": @NO,
                              @"Name": @"",
                              @"Update": @{ @"UpdateDataSource": @"", @"UpdateDataRole": @"", @"LoRaWAN": @"" },
                              @"ClientRequestToken": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-gateway-task-definitions"]
                                                       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}}/wireless-gateway-task-definitions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/wireless-gateway-task-definitions",
  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([
    'AutoCreateTasks' => null,
    'Name' => '',
    'Update' => [
        'UpdateDataSource' => '',
        'UpdateDataRole' => '',
        'LoRaWAN' => ''
    ],
    'ClientRequestToken' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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}}/wireless-gateway-task-definitions', [
  'body' => '{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateway-task-definitions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AutoCreateTasks' => null,
  'Name' => '',
  'Update' => [
    'UpdateDataSource' => '',
    'UpdateDataRole' => '',
    'LoRaWAN' => ''
  ],
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'AutoCreateTasks' => null,
  'Name' => '',
  'Update' => [
    'UpdateDataSource' => '',
    'UpdateDataRole' => '',
    'LoRaWAN' => ''
  ],
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/wireless-gateway-task-definitions');
$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}}/wireless-gateway-task-definitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateway-task-definitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/wireless-gateway-task-definitions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/wireless-gateway-task-definitions"

payload = {
    "AutoCreateTasks": False,
    "Name": "",
    "Update": {
        "UpdateDataSource": "",
        "UpdateDataRole": "",
        "LoRaWAN": ""
    },
    "ClientRequestToken": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateway-task-definitions"

payload <- "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateway-task-definitions")

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  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/wireless-gateway-task-definitions') do |req|
  req.body = "{\n  \"AutoCreateTasks\": false,\n  \"Name\": \"\",\n  \"Update\": {\n    \"UpdateDataSource\": \"\",\n    \"UpdateDataRole\": \"\",\n    \"LoRaWAN\": \"\"\n  },\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateway-task-definitions";

    let payload = json!({
        "AutoCreateTasks": false,
        "Name": "",
        "Update": json!({
            "UpdateDataSource": "",
            "UpdateDataRole": "",
            "LoRaWAN": ""
        }),
        "ClientRequestToken": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/wireless-gateway-task-definitions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AutoCreateTasks": false,\n  "Name": "",\n  "Update": {\n    "UpdateDataSource": "",\n    "UpdateDataRole": "",\n    "LoRaWAN": ""\n  },\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/wireless-gateway-task-definitions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AutoCreateTasks": false,
  "Name": "",
  "Update": [
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  ],
  "ClientRequestToken": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/destinations/:Name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/destinations/:Name")

require "http/client"

url = "{{baseUrl}}/destinations/:Name"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/destinations/:Name"

	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/destinations/:Name HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/destinations/:Name'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/destinations/: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: 'DELETE', url: '{{baseUrl}}/destinations/:Name'};

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

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

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

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

 "{{baseUrl}}/destinations/:Name",
  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}}/destinations/:Name');

echo $response->getBody();

setUrl('{{baseUrl}}/destinations/:Name');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/destinations/:Name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/destinations/:Name' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/destinations/:Name")

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

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

import requests

url = "{{baseUrl}}/destinations/:Name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/destinations/:Name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/destinations/:Name")

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/destinations/:Name') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/destinations/:Name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/destinations/:Name

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/device-profiles/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/device-profiles/:Id")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/device-profiles/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/device-profiles/:Id'};

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

const url = '{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

const url = '{{baseUrl}}/device-profiles/: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}}/device-profiles/: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}}/device-profiles/:Id" in

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

 "{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/device-profiles/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/device-profiles/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/device-profiles/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/device-profiles/:Id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/device-profiles/:Id")

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

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

import requests

url = "{{baseUrl}}/device-profiles/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/device-profiles/:Id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/device-profiles/: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/device-profiles/: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}}/device-profiles/:Id";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/device-profiles/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/device-profiles/:Id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/fuota-tasks/:Id")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/fuota-tasks/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/fuota-tasks/:Id'};

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

const url = '{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

const url = '{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/: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}}/fuota-tasks/:Id" in

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

 "{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/fuota-tasks/:Id")

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

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

import requests

url = "{{baseUrl}}/fuota-tasks/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fuota-tasks/: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/fuota-tasks/: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}}/fuota-tasks/:Id";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/fuota-tasks/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/multicast-groups/:Id")

require "http/client"

url = "{{baseUrl}}/multicast-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}}/multicast-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}}/multicast-groups/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/multicast-groups/:Id'};

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

const url = '{{baseUrl}}/multicast-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}}/multicast-groups/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/multicast-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/multicast-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}}/multicast-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}}/multicast-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}}/multicast-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}}/multicast-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}}/multicast-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}}/multicast-groups/:Id" in

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

 "{{baseUrl}}/multicast-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}}/multicast-groups/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/multicast-groups/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/multicast-groups/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/multicast-groups/:Id")

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

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

import requests

url = "{{baseUrl}}/multicast-groups/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id"

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

content(response, "text")

require 'uri'
require 'net/http'

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

http DELETE {{baseUrl}}/multicast-groups/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")

require "http/client"

url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

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

var client = new RestClient("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

	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/network-analyzer-configurations/:ConfigurationName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .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}}/network-analyzer-configurations/:ConfigurationName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName'
};

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

const url = '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName';
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}}/network-analyzer-configurations/:ConfigurationName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/network-analyzer-configurations/:ConfigurationName',
  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}}/network-analyzer-configurations/:ConfigurationName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');

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}}/network-analyzer-configurations/:ConfigurationName'
};

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

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

const url = '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName';
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}}/network-analyzer-configurations/:ConfigurationName"]
                                                       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}}/network-analyzer-configurations/:ConfigurationName" in

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

 "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName",
  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}}/network-analyzer-configurations/:ConfigurationName');

echo $response->getBody();

setUrl('{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/network-analyzer-configurations/:ConfigurationName")

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

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

import requests

url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")

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/network-analyzer-configurations/:ConfigurationName') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/wireless-devices/:Id/data#messageId" {:query-params {:messageId ""}})

require "http/client"

url = "{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId"

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}}/wireless-devices/:Id/data?messageId=#messageId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId"

	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/wireless-devices/:Id/data?messageId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId"))
    .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}}/wireless-devices/:Id/data?messageId=#messageId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId")
  .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}}/wireless-devices/:Id/data?messageId=#messageId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless-devices/:Id/data#messageId',
  params: {messageId: ''}
};

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

const url = '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId';
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}}/wireless-devices/:Id/data?messageId=#messageId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-devices/:Id/data?messageId=',
  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}}/wireless-devices/:Id/data#messageId',
  qs: {messageId: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/wireless-devices/:Id/data#messageId');

req.query({
  messageId: ''
});

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}}/wireless-devices/:Id/data#messageId',
  params: {messageId: ''}
};

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

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

const url = '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId';
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}}/wireless-devices/:Id/data?messageId=#messageId"]
                                                       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}}/wireless-devices/:Id/data?messageId=#messageId" in

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

 "{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId",
  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}}/wireless-devices/:Id/data?messageId=#messageId');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id/data#messageId');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'messageId' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/wireless-devices/:Id/data#messageId');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'messageId' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/wireless-devices/:Id/data?messageId=")

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

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

import requests

url = "{{baseUrl}}/wireless-devices/:Id/data#messageId"

querystring = {"messageId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id/data#messageId"

queryString <- list(messageId = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId")

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/wireless-devices/:Id/data') do |req|
  req.params['messageId'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/:Id/data#messageId";

    let querystring = [
        ("messageId", ""),
    ];

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

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

    dbg!(results);
}

http DELETE '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/service-profiles/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/service-profiles/:Id")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/service-profiles/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/service-profiles/:Id'};

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

const url = '{{baseUrl}}/service-profiles/: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}}/service-profiles/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

const url = '{{baseUrl}}/service-profiles/: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}}/service-profiles/: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}}/service-profiles/:Id" in

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

 "{{baseUrl}}/service-profiles/: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}}/service-profiles/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/service-profiles/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/service-profiles/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/service-profiles/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-profiles/:Id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/service-profiles/:Id")

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/service-profiles/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/service-profiles/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/service-profiles/: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/service-profiles/: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}}/service-profiles/:Id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/service-profiles/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/service-profiles/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/service-profiles/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-devices/:Id")

require "http/client"

url = "{{baseUrl}}/wireless-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}}/wireless-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}}/wireless-devices/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-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/wireless-devices/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-devices/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-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}}/wireless-devices/:Id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-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}}/wireless-devices/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/wireless-devices/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-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}}/wireless-devices/:Id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-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/wireless-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}}/wireless-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}}/wireless-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}}/wireless-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}}/wireless-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}}/wireless-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}}/wireless-devices/:Id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-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}}/wireless-devices/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-devices/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-devices/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-devices/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-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/wireless-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}}/wireless-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);
}

http DELETE {{baseUrl}}/wireless-devices/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless_device_import_task/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless_device_import_task/:Id")

require "http/client"

url = "{{baseUrl}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless_device_import_task/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless_device_import_task/: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/wireless_device_import_task/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless_device_import_task/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless_device_import_task/:Id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless_device_import_task/: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/wireless_device_import_task/: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}}/wireless_device_import_task/: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}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless_device_import_task/: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}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_device_import_task/:Id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless_device_import_task/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless_device_import_task/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_device_import_task/:Id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless_device_import_task/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless_device_import_task/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless_device_import_task/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless_device_import_task/: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/wireless_device_import_task/: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}}/wireless_device_import_task/:Id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless_device_import_task/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless_device_import_task/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless_device_import_task/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-gateways/:Id")

require "http/client"

url = "{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-gateways/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-gateways/: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/wireless-gateways/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-gateways/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/wireless-gateways/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/: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/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/:Id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-gateways/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-gateways/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateways/: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/wireless-gateways/: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}}/wireless-gateways/:Id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless-gateways/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateways/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/tasks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-gateways/:Id/tasks")

require "http/client"

url = "{{baseUrl}}/wireless-gateways/:Id/tasks"

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}}/wireless-gateways/:Id/tasks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-gateways/:Id/tasks");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id/tasks"

	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/wireless-gateways/:Id/tasks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-gateways/:Id/tasks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/tasks"))
    .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}}/wireless-gateways/:Id/tasks")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-gateways/:Id/tasks")
  .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}}/wireless-gateways/:Id/tasks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless-gateways/:Id/tasks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-gateways/:Id/tasks';
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}}/wireless-gateways/:Id/tasks',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/tasks")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-gateways/:Id/tasks',
  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}}/wireless-gateways/:Id/tasks'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/wireless-gateways/:Id/tasks');

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}}/wireless-gateways/:Id/tasks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-gateways/:Id/tasks';
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}}/wireless-gateways/:Id/tasks"]
                                                       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}}/wireless-gateways/:Id/tasks" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-gateways/:Id/tasks",
  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}}/wireless-gateways/:Id/tasks');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/tasks');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/tasks');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/tasks' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/tasks' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-gateways/:Id/tasks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-gateways/:Id/tasks"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id/tasks"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateways/:Id/tasks")

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/wireless-gateways/:Id/tasks') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/tasks";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless-gateways/:Id/tasks

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/tasks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateways/:Id/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateway-task-definitions/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-gateway-task-definitions/:Id")

require "http/client"

url = "{{baseUrl}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-gateway-task-definitions/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-gateway-task-definitions/: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/wireless-gateway-task-definitions/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-gateway-task-definitions/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless-gateway-task-definitions/:Id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateway-task-definitions/: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/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateway-task-definitions/:Id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-gateway-task-definitions/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateway-task-definitions/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateway-task-definitions/:Id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-gateway-task-definitions/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-gateway-task-definitions/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateway-task-definitions/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateway-task-definitions/: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/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless-gateway-task-definitions/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-gateway-task-definitions/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateway-task-definitions/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Identifier/deregister");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/wireless-devices/:Identifier/deregister")

require "http/client"

url = "{{baseUrl}}/wireless-devices/:Identifier/deregister"

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/wireless-devices/:Identifier/deregister"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-devices/:Identifier/deregister");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-devices/:Identifier/deregister"

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/wireless-devices/:Identifier/deregister HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/wireless-devices/:Identifier/deregister")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Identifier/deregister"))
    .method("PATCH", 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}}/wireless-devices/:Identifier/deregister")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/wireless-devices/:Identifier/deregister")
  .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('PATCH', '{{baseUrl}}/wireless-devices/:Identifier/deregister');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless-devices/:Identifier/deregister'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-devices/:Identifier/deregister';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-devices/:Identifier/deregister',
  method: 'PATCH',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Identifier/deregister")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-devices/:Identifier/deregister',
  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: 'PATCH',
  url: '{{baseUrl}}/wireless-devices/:Identifier/deregister'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/wireless-devices/:Identifier/deregister');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless-devices/:Identifier/deregister'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-devices/:Identifier/deregister';
const options = {method: 'PATCH'};

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}}/wireless-devices/:Identifier/deregister"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/wireless-devices/:Identifier/deregister" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-devices/:Identifier/deregister",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/wireless-devices/:Identifier/deregister');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Identifier/deregister');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-devices/:Identifier/deregister');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Identifier/deregister' -Method PATCH 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Identifier/deregister' -Method PATCH 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/wireless-devices/:Identifier/deregister")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-devices/:Identifier/deregister"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Identifier/deregister"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-devices/:Identifier/deregister")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/wireless-devices/:Identifier/deregister') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/:Identifier/deregister";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PATCH {{baseUrl}}/wireless-devices/:Identifier/deregister

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Identifier/deregister

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-devices/:Identifier/deregister")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType" {:query-params {:partnerType ""}})

require "http/client"

url = "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"

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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"

	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/partner-accounts/:PartnerAccountId?partnerType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"))
    .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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType',
  params: {partnerType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType';
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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/partner-accounts/:PartnerAccountId?partnerType=',
  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}}/partner-accounts/:PartnerAccountId#partnerType',
  qs: {partnerType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');

req.query({
  partnerType: ''
});

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}}/partner-accounts/:PartnerAccountId#partnerType',
  params: {partnerType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType';
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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"]
                                                       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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType",
  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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType');

echo $response->getBody();

setUrl('{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'partnerType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'partnerType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/partner-accounts/:PartnerAccountId?partnerType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType"

querystring = {"partnerType":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType"

queryString <- list(partnerType = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")

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/partner-accounts/:PartnerAccountId') do |req|
  req.params['partnerType'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType";

    let querystring = [
        ("partnerType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")

require "http/client"

url = "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"

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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"

	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/fuota-tasks/:Id/multicast-groups/:MulticastGroupId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"))
    .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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")
  .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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId';
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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/fuota-tasks/:Id/multicast-groups/:MulticastGroupId',
  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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId');

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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId';
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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"]
                                                       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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId",
  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}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")

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/fuota-tasks/:Id/multicast-groups/:MulticastGroupId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")

require "http/client"

url = "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"

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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"

	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/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"))
    .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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")
  .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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId';
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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId',
  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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId');

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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId';
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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"]
                                                       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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId",
  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}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId');

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")

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/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")

require "http/client"

url = "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"

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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"

	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/multicast-groups/:Id/wireless-devices/:WirelessDeviceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"))
    .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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")
  .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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId';
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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/multicast-groups/:Id/wireless-devices/:WirelessDeviceId',
  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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId');

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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId';
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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"]
                                                       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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId",
  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}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId');

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")

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/multicast-groups/:Id/wireless-devices/:WirelessDeviceId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id/thing");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-devices/:Id/thing")

require "http/client"

url = "{{baseUrl}}/wireless-devices/:Id/thing"

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}}/wireless-devices/:Id/thing"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-devices/:Id/thing");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-devices/:Id/thing"

	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/wireless-devices/:Id/thing HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-devices/:Id/thing")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/thing"))
    .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}}/wireless-devices/:Id/thing")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-devices/:Id/thing")
  .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}}/wireless-devices/:Id/thing');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless-devices/:Id/thing'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-devices/:Id/thing';
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}}/wireless-devices/:Id/thing',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/thing")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-devices/:Id/thing',
  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}}/wireless-devices/:Id/thing'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/wireless-devices/:Id/thing');

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}}/wireless-devices/:Id/thing'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-devices/:Id/thing';
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}}/wireless-devices/:Id/thing"]
                                                       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}}/wireless-devices/:Id/thing" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-devices/:Id/thing",
  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}}/wireless-devices/:Id/thing');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id/thing');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-devices/:Id/thing');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Id/thing' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/thing' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-devices/:Id/thing")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-devices/:Id/thing"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id/thing"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-devices/:Id/thing")

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/wireless-devices/:Id/thing') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/:Id/thing";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless-devices/:Id/thing

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id/thing

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-devices/:Id/thing")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/certificate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-gateways/:Id/certificate")

require "http/client"

url = "{{baseUrl}}/wireless-gateways/:Id/certificate"

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}}/wireless-gateways/:Id/certificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-gateways/:Id/certificate");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id/certificate"

	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/wireless-gateways/:Id/certificate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-gateways/:Id/certificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/certificate"))
    .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}}/wireless-gateways/:Id/certificate")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-gateways/:Id/certificate")
  .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}}/wireless-gateways/:Id/certificate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless-gateways/:Id/certificate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-gateways/:Id/certificate';
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}}/wireless-gateways/:Id/certificate',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/certificate")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-gateways/:Id/certificate',
  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}}/wireless-gateways/:Id/certificate'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/wireless-gateways/:Id/certificate');

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}}/wireless-gateways/:Id/certificate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-gateways/:Id/certificate';
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}}/wireless-gateways/:Id/certificate"]
                                                       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}}/wireless-gateways/:Id/certificate" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-gateways/:Id/certificate",
  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}}/wireless-gateways/:Id/certificate');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/certificate');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/certificate');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/certificate' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/certificate' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-gateways/:Id/certificate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-gateways/:Id/certificate"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id/certificate"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateways/:Id/certificate")

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/wireless-gateways/:Id/certificate') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/certificate";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless-gateways/:Id/certificate

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/certificate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateways/:Id/certificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/thing");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/wireless-gateways/:Id/thing")

require "http/client"

url = "{{baseUrl}}/wireless-gateways/:Id/thing"

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}}/wireless-gateways/:Id/thing"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/wireless-gateways/:Id/thing");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id/thing"

	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/wireless-gateways/:Id/thing HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/wireless-gateways/:Id/thing")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/thing"))
    .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}}/wireless-gateways/:Id/thing")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/wireless-gateways/:Id/thing")
  .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}}/wireless-gateways/:Id/thing');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/wireless-gateways/:Id/thing'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-gateways/:Id/thing';
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}}/wireless-gateways/:Id/thing',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/thing")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-gateways/:Id/thing',
  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}}/wireless-gateways/:Id/thing'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/wireless-gateways/:Id/thing');

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}}/wireless-gateways/:Id/thing'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless-gateways/:Id/thing';
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}}/wireless-gateways/:Id/thing"]
                                                       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}}/wireless-gateways/:Id/thing" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-gateways/:Id/thing",
  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}}/wireless-gateways/:Id/thing');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/thing');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/thing');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/thing' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/thing' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/wireless-gateways/:Id/thing")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-gateways/:Id/thing"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id/thing"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateways/:Id/thing")

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/wireless-gateways/:Id/thing') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/thing";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/wireless-gateways/:Id/thing

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/thing

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateways/:Id/thing")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/destinations/:Name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/destinations/:Name")

require "http/client"

url = "{{baseUrl}}/destinations/:Name"

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}}/destinations/:Name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/destinations/:Name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/destinations/:Name"

	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/destinations/:Name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/destinations/:Name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/destinations/:Name"))
    .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}}/destinations/:Name")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/destinations/:Name")
  .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}}/destinations/:Name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/destinations/:Name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/destinations/:Name';
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}}/destinations/:Name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/destinations/:Name")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/destinations/:Name',
  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}}/destinations/:Name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/destinations/: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: 'GET', url: '{{baseUrl}}/destinations/:Name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/destinations/:Name';
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}}/destinations/:Name"]
                                                       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}}/destinations/:Name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/destinations/:Name",
  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}}/destinations/:Name');

echo $response->getBody();

setUrl('{{baseUrl}}/destinations/:Name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/destinations/:Name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/destinations/:Name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/destinations/:Name' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/destinations/:Name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/destinations/:Name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/destinations/:Name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/destinations/:Name")

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/destinations/:Name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/destinations/:Name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/destinations/:Name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/destinations/:Name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/destinations/:Name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/device-profiles/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/device-profiles/:Id")

require "http/client"

url = "{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/device-profiles/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/device-profiles/: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/device-profiles/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/device-profiles/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/device-profiles/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/device-profiles/:Id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/device-profiles/: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}}/device-profiles/: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}}/device-profiles/: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}}/device-profiles/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/device-profiles/: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}}/device-profiles/: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}}/device-profiles/:Id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/device-profiles/: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}}/device-profiles/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/device-profiles/:Id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/device-profiles/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/device-profiles/:Id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/device-profiles/:Id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/device-profiles/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/device-profiles/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/device-profiles/:Id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/device-profiles/: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/device-profiles/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/device-profiles/:Id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/device-profiles/:Id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/device-profiles/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/device-profiles/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-configurations-resource-types");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/event-configurations-resource-types")

require "http/client"

url = "{{baseUrl}}/event-configurations-resource-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}}/event-configurations-resource-types"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/event-configurations-resource-types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/event-configurations-resource-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/event-configurations-resource-types HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event-configurations-resource-types")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-configurations-resource-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}}/event-configurations-resource-types")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/event-configurations-resource-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}}/event-configurations-resource-types');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/event-configurations-resource-types'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/event-configurations-resource-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}}/event-configurations-resource-types',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/event-configurations-resource-types")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/event-configurations-resource-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}}/event-configurations-resource-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}}/event-configurations-resource-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}}/event-configurations-resource-types'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/event-configurations-resource-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}}/event-configurations-resource-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}}/event-configurations-resource-types" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/event-configurations-resource-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}}/event-configurations-resource-types');

echo $response->getBody();

setUrl('{{baseUrl}}/event-configurations-resource-types');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/event-configurations-resource-types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/event-configurations-resource-types' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-configurations-resource-types' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/event-configurations-resource-types")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/event-configurations-resource-types"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-configurations-resource-types"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/event-configurations-resource-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/event-configurations-resource-types') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/event-configurations-resource-types";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/event-configurations-resource-types

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/event-configurations-resource-types

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event-configurations-resource-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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/fuota-tasks/:Id")

require "http/client"

url = "{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/fuota-tasks/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/fuota-tasks/: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/fuota-tasks/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/fuota-tasks/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/fuota-tasks/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/fuota-tasks/: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}}/fuota-tasks/: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}}/fuota-tasks/: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}}/fuota-tasks/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/: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}}/fuota-tasks/:Id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/fuota-tasks/: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}}/fuota-tasks/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/fuota-tasks/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/fuota-tasks/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fuota-tasks/: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/fuota-tasks/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/fuota-tasks/:Id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/fuota-tasks/:Id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log-levels");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/log-levels")

require "http/client"

url = "{{baseUrl}}/log-levels"

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}}/log-levels"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/log-levels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/log-levels"

	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/log-levels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/log-levels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log-levels"))
    .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}}/log-levels")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/log-levels")
  .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}}/log-levels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/log-levels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/log-levels';
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}}/log-levels',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/log-levels")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/log-levels',
  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}}/log-levels'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/log-levels');

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}}/log-levels'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/log-levels';
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}}/log-levels"]
                                                       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}}/log-levels" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/log-levels",
  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}}/log-levels');

echo $response->getBody();

setUrl('{{baseUrl}}/log-levels');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/log-levels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/log-levels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/log-levels' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/log-levels")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/log-levels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/log-levels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/log-levels")

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/log-levels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/log-levels";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/log-levels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/log-levels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log-levels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/multicast-groups/:Id")

require "http/client"

url = "{{baseUrl}}/multicast-groups/: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}}/multicast-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}}/multicast-groups/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/multicast-groups/: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/multicast-groups/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/multicast-groups/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/: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}}/multicast-groups/:Id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/multicast-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('GET', '{{baseUrl}}/multicast-groups/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/multicast-groups/:Id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/: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}}/multicast-groups/:Id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/multicast-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: 'GET', url: '{{baseUrl}}/multicast-groups/: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}}/multicast-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: 'GET', url: '{{baseUrl}}/multicast-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}}/multicast-groups/: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}}/multicast-groups/: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}}/multicast-groups/:Id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/multicast-groups/: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}}/multicast-groups/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/multicast-groups/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/multicast-groups/:Id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/multicast-groups/:Id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/multicast-groups/: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/multicast-groups/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/multicast-groups/:Id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/multicast-groups/:Id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/session");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/multicast-groups/:Id/session")

require "http/client"

url = "{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/multicast-groups/:Id/session");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id/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/multicast-groups/:Id/session HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/multicast-groups/:Id/session")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/multicast-groups/:Id/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/session")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/multicast-groups/:Id/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}}/multicast-groups/:Id/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}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/multicast-groups/:Id/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}}/multicast-groups/:Id/session');

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/session');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/multicast-groups/:Id/session');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/multicast-groups/:Id/session' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/session' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/multicast-groups/:Id/session")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id/session"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/session"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/multicast-groups/:Id/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/multicast-groups/:Id/session') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/multicast-groups/:Id/session";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/multicast-groups/:Id/session

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/session

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")

require "http/client"

url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

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}}/network-analyzer-configurations/:ConfigurationName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

	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/network-analyzer-configurations/:ConfigurationName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"))
    .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}}/network-analyzer-configurations/:ConfigurationName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .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}}/network-analyzer-configurations/:ConfigurationName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName';
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}}/network-analyzer-configurations/:ConfigurationName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/network-analyzer-configurations/:ConfigurationName',
  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}}/network-analyzer-configurations/:ConfigurationName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');

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}}/network-analyzer-configurations/:ConfigurationName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName';
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}}/network-analyzer-configurations/:ConfigurationName"]
                                                       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}}/network-analyzer-configurations/:ConfigurationName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName",
  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}}/network-analyzer-configurations/:ConfigurationName');

echo $response->getBody();

setUrl('{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/network-analyzer-configurations/:ConfigurationName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")

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/network-analyzer-configurations/:ConfigurationName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType" {:query-params {:partnerType ""}})

require "http/client"

url = "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"

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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"

	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/partner-accounts/:PartnerAccountId?partnerType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"))
    .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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType',
  params: {partnerType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType';
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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/partner-accounts/:PartnerAccountId?partnerType=',
  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}}/partner-accounts/:PartnerAccountId#partnerType',
  qs: {partnerType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');

req.query({
  partnerType: ''
});

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}}/partner-accounts/:PartnerAccountId#partnerType',
  params: {partnerType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType';
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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"]
                                                       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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType",
  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}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType');

echo $response->getBody();

setUrl('{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'partnerType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'partnerType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/partner-accounts/:PartnerAccountId?partnerType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType"

querystring = {"partnerType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType"

queryString <- list(partnerType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")

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/partner-accounts/:PartnerAccountId') do |req|
  req.params['partnerType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType";

    let querystring = [
        ("partnerType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/positions/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"

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/:ResourceIdentifier?resourceType=#resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"

	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/:ResourceIdentifier?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"))
    .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/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .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/:ResourceIdentifier?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType';
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/:ResourceIdentifier?resourceType=#resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/positions/:ResourceIdentifier?resourceType=',
  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/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''}
};

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/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

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/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType';
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/:ResourceIdentifier?resourceType=#resourceType"]
                                                       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/:ResourceIdentifier?resourceType=#resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType",
  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/:ResourceIdentifier?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/positions/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/positions/:ResourceIdentifier#resourceType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/positions/:ResourceIdentifier?resourceType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/positions/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/positions/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")

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/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/positions/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"

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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"

	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/position-configurations/:ResourceIdentifier?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"))
    .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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType';
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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/position-configurations/:ResourceIdentifier?resourceType=',
  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}}/position-configurations/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

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}}/position-configurations/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType';
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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"]
                                                       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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType",
  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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/position-configurations/:ResourceIdentifier?resourceType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")

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/position-configurations/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/position-estimate");

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  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/position-estimate" {:content-type :json
                                                              :form-params {:WiFiAccessPoints [{:MacAddress ""
                                                                                                :Rss ""}]
                                                                            :CellTowers {:Gsm ""
                                                                                         :Wcdma ""
                                                                                         :Tdscdma ""
                                                                                         :Lte ""
                                                                                         :Cdma ""}
                                                                            :Ip {:IpAddress ""}
                                                                            :Gnss {:Payload ""
                                                                                   :CaptureTime ""
                                                                                   :CaptureTimeAccuracy ""
                                                                                   :AssistPosition ""
                                                                                   :AssistAltitude ""
                                                                                   :Use2DSolver ""}
                                                                            :Timestamp ""}})

require "http/client"

url = "{{baseUrl}}/position-estimate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/position-estimate"),
    Content = new StringContent("{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/position-estimate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/position-estimate"

	payload := strings.NewReader("{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/position-estimate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 405

{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/position-estimate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/position-estimate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/position-estimate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/position-estimate")
  .header("content-type", "application/json")
  .body("{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WiFiAccessPoints: [
    {
      MacAddress: '',
      Rss: ''
    }
  ],
  CellTowers: {
    Gsm: '',
    Wcdma: '',
    Tdscdma: '',
    Lte: '',
    Cdma: ''
  },
  Ip: {
    IpAddress: ''
  },
  Gnss: {
    Payload: '',
    CaptureTime: '',
    CaptureTimeAccuracy: '',
    AssistPosition: '',
    AssistAltitude: '',
    Use2DSolver: ''
  },
  Timestamp: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/position-estimate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/position-estimate',
  headers: {'content-type': 'application/json'},
  data: {
    WiFiAccessPoints: [{MacAddress: '', Rss: ''}],
    CellTowers: {Gsm: '', Wcdma: '', Tdscdma: '', Lte: '', Cdma: ''},
    Ip: {IpAddress: ''},
    Gnss: {
      Payload: '',
      CaptureTime: '',
      CaptureTimeAccuracy: '',
      AssistPosition: '',
      AssistAltitude: '',
      Use2DSolver: ''
    },
    Timestamp: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/position-estimate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WiFiAccessPoints":[{"MacAddress":"","Rss":""}],"CellTowers":{"Gsm":"","Wcdma":"","Tdscdma":"","Lte":"","Cdma":""},"Ip":{"IpAddress":""},"Gnss":{"Payload":"","CaptureTime":"","CaptureTimeAccuracy":"","AssistPosition":"","AssistAltitude":"","Use2DSolver":""},"Timestamp":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/position-estimate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WiFiAccessPoints": [\n    {\n      "MacAddress": "",\n      "Rss": ""\n    }\n  ],\n  "CellTowers": {\n    "Gsm": "",\n    "Wcdma": "",\n    "Tdscdma": "",\n    "Lte": "",\n    "Cdma": ""\n  },\n  "Ip": {\n    "IpAddress": ""\n  },\n  "Gnss": {\n    "Payload": "",\n    "CaptureTime": "",\n    "CaptureTimeAccuracy": "",\n    "AssistPosition": "",\n    "AssistAltitude": "",\n    "Use2DSolver": ""\n  },\n  "Timestamp": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/position-estimate")
  .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/position-estimate',
  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({
  WiFiAccessPoints: [{MacAddress: '', Rss: ''}],
  CellTowers: {Gsm: '', Wcdma: '', Tdscdma: '', Lte: '', Cdma: ''},
  Ip: {IpAddress: ''},
  Gnss: {
    Payload: '',
    CaptureTime: '',
    CaptureTimeAccuracy: '',
    AssistPosition: '',
    AssistAltitude: '',
    Use2DSolver: ''
  },
  Timestamp: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/position-estimate',
  headers: {'content-type': 'application/json'},
  body: {
    WiFiAccessPoints: [{MacAddress: '', Rss: ''}],
    CellTowers: {Gsm: '', Wcdma: '', Tdscdma: '', Lte: '', Cdma: ''},
    Ip: {IpAddress: ''},
    Gnss: {
      Payload: '',
      CaptureTime: '',
      CaptureTimeAccuracy: '',
      AssistPosition: '',
      AssistAltitude: '',
      Use2DSolver: ''
    },
    Timestamp: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/position-estimate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WiFiAccessPoints: [
    {
      MacAddress: '',
      Rss: ''
    }
  ],
  CellTowers: {
    Gsm: '',
    Wcdma: '',
    Tdscdma: '',
    Lte: '',
    Cdma: ''
  },
  Ip: {
    IpAddress: ''
  },
  Gnss: {
    Payload: '',
    CaptureTime: '',
    CaptureTimeAccuracy: '',
    AssistPosition: '',
    AssistAltitude: '',
    Use2DSolver: ''
  },
  Timestamp: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/position-estimate',
  headers: {'content-type': 'application/json'},
  data: {
    WiFiAccessPoints: [{MacAddress: '', Rss: ''}],
    CellTowers: {Gsm: '', Wcdma: '', Tdscdma: '', Lte: '', Cdma: ''},
    Ip: {IpAddress: ''},
    Gnss: {
      Payload: '',
      CaptureTime: '',
      CaptureTimeAccuracy: '',
      AssistPosition: '',
      AssistAltitude: '',
      Use2DSolver: ''
    },
    Timestamp: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/position-estimate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"WiFiAccessPoints":[{"MacAddress":"","Rss":""}],"CellTowers":{"Gsm":"","Wcdma":"","Tdscdma":"","Lte":"","Cdma":""},"Ip":{"IpAddress":""},"Gnss":{"Payload":"","CaptureTime":"","CaptureTimeAccuracy":"","AssistPosition":"","AssistAltitude":"","Use2DSolver":""},"Timestamp":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WiFiAccessPoints": @[ @{ @"MacAddress": @"", @"Rss": @"" } ],
                              @"CellTowers": @{ @"Gsm": @"", @"Wcdma": @"", @"Tdscdma": @"", @"Lte": @"", @"Cdma": @"" },
                              @"Ip": @{ @"IpAddress": @"" },
                              @"Gnss": @{ @"Payload": @"", @"CaptureTime": @"", @"CaptureTimeAccuracy": @"", @"AssistPosition": @"", @"AssistAltitude": @"", @"Use2DSolver": @"" },
                              @"Timestamp": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/position-estimate"]
                                                       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}}/position-estimate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/position-estimate",
  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([
    'WiFiAccessPoints' => [
        [
                'MacAddress' => '',
                'Rss' => ''
        ]
    ],
    'CellTowers' => [
        'Gsm' => '',
        'Wcdma' => '',
        'Tdscdma' => '',
        'Lte' => '',
        'Cdma' => ''
    ],
    'Ip' => [
        'IpAddress' => ''
    ],
    'Gnss' => [
        'Payload' => '',
        'CaptureTime' => '',
        'CaptureTimeAccuracy' => '',
        'AssistPosition' => '',
        'AssistAltitude' => '',
        'Use2DSolver' => ''
    ],
    'Timestamp' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/position-estimate', [
  'body' => '{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/position-estimate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WiFiAccessPoints' => [
    [
        'MacAddress' => '',
        'Rss' => ''
    ]
  ],
  'CellTowers' => [
    'Gsm' => '',
    'Wcdma' => '',
    'Tdscdma' => '',
    'Lte' => '',
    'Cdma' => ''
  ],
  'Ip' => [
    'IpAddress' => ''
  ],
  'Gnss' => [
    'Payload' => '',
    'CaptureTime' => '',
    'CaptureTimeAccuracy' => '',
    'AssistPosition' => '',
    'AssistAltitude' => '',
    'Use2DSolver' => ''
  ],
  'Timestamp' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WiFiAccessPoints' => [
    [
        'MacAddress' => '',
        'Rss' => ''
    ]
  ],
  'CellTowers' => [
    'Gsm' => '',
    'Wcdma' => '',
    'Tdscdma' => '',
    'Lte' => '',
    'Cdma' => ''
  ],
  'Ip' => [
    'IpAddress' => ''
  ],
  'Gnss' => [
    'Payload' => '',
    'CaptureTime' => '',
    'CaptureTimeAccuracy' => '',
    'AssistPosition' => '',
    'AssistAltitude' => '',
    'Use2DSolver' => ''
  ],
  'Timestamp' => ''
]));
$request->setRequestUrl('{{baseUrl}}/position-estimate');
$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}}/position-estimate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/position-estimate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/position-estimate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/position-estimate"

payload = {
    "WiFiAccessPoints": [
        {
            "MacAddress": "",
            "Rss": ""
        }
    ],
    "CellTowers": {
        "Gsm": "",
        "Wcdma": "",
        "Tdscdma": "",
        "Lte": "",
        "Cdma": ""
    },
    "Ip": { "IpAddress": "" },
    "Gnss": {
        "Payload": "",
        "CaptureTime": "",
        "CaptureTimeAccuracy": "",
        "AssistPosition": "",
        "AssistAltitude": "",
        "Use2DSolver": ""
    },
    "Timestamp": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/position-estimate"

payload <- "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/position-estimate")

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  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/position-estimate') do |req|
  req.body = "{\n  \"WiFiAccessPoints\": [\n    {\n      \"MacAddress\": \"\",\n      \"Rss\": \"\"\n    }\n  ],\n  \"CellTowers\": {\n    \"Gsm\": \"\",\n    \"Wcdma\": \"\",\n    \"Tdscdma\": \"\",\n    \"Lte\": \"\",\n    \"Cdma\": \"\"\n  },\n  \"Ip\": {\n    \"IpAddress\": \"\"\n  },\n  \"Gnss\": {\n    \"Payload\": \"\",\n    \"CaptureTime\": \"\",\n    \"CaptureTimeAccuracy\": \"\",\n    \"AssistPosition\": \"\",\n    \"AssistAltitude\": \"\",\n    \"Use2DSolver\": \"\"\n  },\n  \"Timestamp\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/position-estimate";

    let payload = json!({
        "WiFiAccessPoints": (
            json!({
                "MacAddress": "",
                "Rss": ""
            })
        ),
        "CellTowers": json!({
            "Gsm": "",
            "Wcdma": "",
            "Tdscdma": "",
            "Lte": "",
            "Cdma": ""
        }),
        "Ip": json!({"IpAddress": ""}),
        "Gnss": json!({
            "Payload": "",
            "CaptureTime": "",
            "CaptureTimeAccuracy": "",
            "AssistPosition": "",
            "AssistAltitude": "",
            "Use2DSolver": ""
        }),
        "Timestamp": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}' |  \
  http POST {{baseUrl}}/position-estimate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "WiFiAccessPoints": [\n    {\n      "MacAddress": "",\n      "Rss": ""\n    }\n  ],\n  "CellTowers": {\n    "Gsm": "",\n    "Wcdma": "",\n    "Tdscdma": "",\n    "Lte": "",\n    "Cdma": ""\n  },\n  "Ip": {\n    "IpAddress": ""\n  },\n  "Gnss": {\n    "Payload": "",\n    "CaptureTime": "",\n    "CaptureTimeAccuracy": "",\n    "AssistPosition": "",\n    "AssistAltitude": "",\n    "Use2DSolver": ""\n  },\n  "Timestamp": ""\n}' \
  --output-document \
  - {{baseUrl}}/position-estimate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "WiFiAccessPoints": [
    [
      "MacAddress": "",
      "Rss": ""
    ]
  ],
  "CellTowers": [
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  ],
  "Ip": ["IpAddress": ""],
  "Gnss": [
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  ],
  "Timestamp": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/position-estimate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/event-configurations/:Identifier#identifierType" {:query-params {:identifierType ""}})

require "http/client"

url = "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"

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}}/event-configurations/:Identifier?identifierType=#identifierType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"

	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/event-configurations/:Identifier?identifierType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"))
    .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}}/event-configurations/:Identifier?identifierType=#identifierType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .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}}/event-configurations/:Identifier?identifierType=#identifierType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/event-configurations/:Identifier#identifierType',
  params: {identifierType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType';
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}}/event-configurations/:Identifier?identifierType=#identifierType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/event-configurations/:Identifier?identifierType=',
  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}}/event-configurations/:Identifier#identifierType',
  qs: {identifierType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/event-configurations/:Identifier#identifierType');

req.query({
  identifierType: ''
});

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}}/event-configurations/:Identifier#identifierType',
  params: {identifierType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType';
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}}/event-configurations/:Identifier?identifierType=#identifierType"]
                                                       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}}/event-configurations/:Identifier?identifierType=#identifierType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType",
  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}}/event-configurations/:Identifier?identifierType=#identifierType');

echo $response->getBody();

setUrl('{{baseUrl}}/event-configurations/:Identifier#identifierType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'identifierType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/event-configurations/:Identifier#identifierType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'identifierType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/event-configurations/:Identifier?identifierType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/event-configurations/:Identifier#identifierType"

querystring = {"identifierType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-configurations/:Identifier#identifierType"

queryString <- list(identifierType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")

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/event-configurations/:Identifier') do |req|
  req.params['identifierType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/event-configurations/:Identifier#identifierType";

    let querystring = [
        ("identifierType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"

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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"

	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/log-levels/:ResourceIdentifier?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"))
    .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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType';
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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/log-levels/:ResourceIdentifier?resourceType=',
  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}}/log-levels/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

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}}/log-levels/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType';
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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"]
                                                       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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType",
  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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/log-levels/:ResourceIdentifier?resourceType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")

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/log-levels/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"

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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"

	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/resource-positions/:ResourceIdentifier?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"))
    .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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType';
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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource-positions/:ResourceIdentifier?resourceType=',
  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}}/resource-positions/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

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}}/resource-positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType';
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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"]
                                                       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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType",
  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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resource-positions/:ResourceIdentifier?resourceType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")

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/resource-positions/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/service-endpoint");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/service-endpoint")

require "http/client"

url = "{{baseUrl}}/service-endpoint"

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}}/service-endpoint"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/service-endpoint");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/service-endpoint"

	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/service-endpoint HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/service-endpoint")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/service-endpoint"))
    .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}}/service-endpoint")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/service-endpoint")
  .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}}/service-endpoint');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/service-endpoint'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/service-endpoint';
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}}/service-endpoint',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/service-endpoint")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/service-endpoint',
  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}}/service-endpoint'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/service-endpoint');

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}}/service-endpoint'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/service-endpoint';
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}}/service-endpoint"]
                                                       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}}/service-endpoint" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/service-endpoint",
  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}}/service-endpoint');

echo $response->getBody();

setUrl('{{baseUrl}}/service-endpoint');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/service-endpoint');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/service-endpoint' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-endpoint' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/service-endpoint")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/service-endpoint"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/service-endpoint"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/service-endpoint")

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/service-endpoint') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/service-endpoint";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/service-endpoint

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/service-endpoint

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/service-endpoint")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/service-profiles/:Id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/service-profiles/:Id")

require "http/client"

url = "{{baseUrl}}/service-profiles/: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}}/service-profiles/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/service-profiles/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/service-profiles/: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/service-profiles/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/service-profiles/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/service-profiles/: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}}/service-profiles/:Id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/service-profiles/: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}}/service-profiles/:Id');

xhr.send(data);