AWS IoT Wireless

POST AssociateAwsAccountWithPartnerAccount

{{baseUrl}}/partner-accounts

BODY json

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

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/partner-accounts \
  --header 'content-type: application/json' \
  --data '{
  "Sidewalk": {
    "AmazonId": "",
    "AppServerPrivateKey": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

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()

PUT AssociateMulticastGroupWithFuotaTask

{{baseUrl}}/fuota-tasks/:Id/multicast-group

QUERY PARAMS

BODY json

{
  "MulticastGroupId": ""
}

Examples

REQUEST

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

curl --request PUT \
  --url {{baseUrl}}/fuota-tasks/:Id/multicast-group \
  --header 'content-type: application/json' \
  --data '{
  "MulticastGroupId": ""
}'

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()

PUT AssociateWirelessDeviceWithFuotaTask

{{baseUrl}}/fuota-tasks/:Id/wireless-device

QUERY PARAMS

BODY json

{
  "WirelessDeviceId": ""
}

Examples

REQUEST

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

curl --request PUT \
  --url {{baseUrl}}/fuota-tasks/:Id/wireless-device \
  --header 'content-type: application/json' \
  --data '{
  "WirelessDeviceId": ""
}'

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()

PUT AssociateWirelessDeviceWithMulticastGroup

{{baseUrl}}/multicast-groups/:Id/wireless-device

QUERY PARAMS

BODY json

{
  "WirelessDeviceId": ""
}

Examples

REQUEST

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

curl --request PUT \
  --url {{baseUrl}}/multicast-groups/:Id/wireless-device \
  --header 'content-type: application/json' \
  --data '{
  "WirelessDeviceId": ""
}'

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()

PUT AssociateWirelessDeviceWithThing

{{baseUrl}}/wireless-devices/:Id/thing

QUERY PARAMS

BODY json

{
  "ThingArn": ""
}

Examples

REQUEST

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

curl --request PUT \
  --url {{baseUrl}}/wireless-devices/:Id/thing \
  --header 'content-type: application/json' \
  --data '{
  "ThingArn": ""
}'

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()

PUT AssociateWirelessGatewayWithCertificate

{{baseUrl}}/wireless-gateways/:Id/certificate

QUERY PARAMS

BODY json

{
  "IotCertificateId": ""
}

Examples

REQUEST

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

curl --request PUT \
  --url {{baseUrl}}/wireless-gateways/:Id/certificate \
  --header 'content-type: application/json' \
  --data '{
  "IotCertificateId": ""
}'

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()

PUT AssociateWirelessGatewayWithThing

{{baseUrl}}/wireless-gateways/:Id/thing

QUERY PARAMS

BODY json

{
  "ThingArn": ""
}

Examples

REQUEST

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

curl --request PUT \
  --url {{baseUrl}}/wireless-gateways/:Id/thing \
  --header 'content-type: application/json' \
  --data '{
  "ThingArn": ""
}'

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()

DELETE CancelMulticastGroupSession

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

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/multicast-groups/:Id/session

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()

POST CreateDestination

{{baseUrl}}/destinations

BODY json

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

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/destinations \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

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()

POST CreateDeviceProfile

{{baseUrl}}/device-profiles

BODY json

{
  "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": {}
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/device-profiles \
  --header '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": {}
}'

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()

POST CreateFuotaTask

{{baseUrl}}/fuota-tasks

BODY json

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

Examples

REQUEST

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

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

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()

POST CreateMulticastGroup

{{baseUrl}}/multicast-groups

BODY json

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

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/multicast-groups \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Description": "",
  "ClientRequestToken": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

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()

POST CreateNetworkAnalyzerConfiguration

{{baseUrl}}/network-analyzer-configurations

BODY json

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

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/network-analyzer-configurations \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevices": [],
  "WirelessGateways": [],
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

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()

POST CreateServiceProfile

{{baseUrl}}/service-profiles

BODY json

{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/service-profiles \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "LoRaWAN": {
    "AddGwMetadata": "",
    "DrMin": "",
    "DrMax": "",
    "PrAllowed": "",
    "RaAllowed": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

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()

POST CreateWirelessDevice

{{baseUrl}}/wireless-devices

BODY json

{
  "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": ""
  }
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/wireless-devices \
  --header '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": ""
  }
}'

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()

POST CreateWirelessGateway

{{baseUrl}}/wireless-gateways

BODY json

{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/wireless-gateways \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "GatewayEui": "",
    "RfRegion": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "SubBands": [],
    "Beaconing": "",
    "MaxEirp": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientRequestToken": ""
}'

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()

POST CreateWirelessGatewayTask

{{baseUrl}}/wireless-gateways/:Id/tasks

QUERY PARAMS

BODY json

{
  "WirelessGatewayTaskDefinitionId": ""
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/wireless-gateways/:Id/tasks \
  --header 'content-type: application/json' \
  --data '{
  "WirelessGatewayTaskDefinitionId": ""
}'

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()

POST CreateWirelessGatewayTaskDefinition

{{baseUrl}}/wireless-gateway-task-definitions

BODY json

{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/wireless-gateway-task-definitions \
  --header 'content-type: application/json' \
  --data '{
  "AutoCreateTasks": false,
  "Name": "",
  "Update": {
    "UpdateDataSource": "",
    "UpdateDataRole": "",
    "LoRaWAN": ""
  },
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

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()

DELETE DeleteDestination

{{baseUrl}}/destinations/:Name

QUERY PARAMS

Name

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/destinations/:Name

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()

DELETE DeleteDeviceProfile

{{baseUrl}}/device-profiles/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/device-profiles/:Id

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()

DELETE DeleteFuotaTask

{{baseUrl}}/fuota-tasks/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/fuota-tasks/:Id

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()

DELETE DeleteMulticastGroup

{{baseUrl}}/multicast-groups/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/multicast-groups/:Id

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()

DELETE DeleteNetworkAnalyzerConfiguration

{{baseUrl}}/network-analyzer-configurations/:ConfigurationName

QUERY PARAMS

ConfigurationName

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

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()

DELETE DeleteQueuedMessages

{{baseUrl}}/wireless-devices/:Id/data#messageId

QUERY PARAMS

messageId

Examples

REQUEST

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

curl --request DELETE \
  --url '{{baseUrl}}/wireless-devices/:Id/data?messageId=#messageId'

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()

DELETE DeleteServiceProfile

{{baseUrl}}/service-profiles/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/service-profiles/:Id

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()

DELETE DeleteWirelessDevice

{{baseUrl}}/wireless-devices/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-devices/:Id

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()

DELETE DeleteWirelessDeviceImportTask

{{baseUrl}}/wireless_device_import_task/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless_device_import_task/:Id

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()

DELETE DeleteWirelessGateway

{{baseUrl}}/wireless-gateways/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-gateways/:Id

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()

DELETE DeleteWirelessGatewayTask

{{baseUrl}}/wireless-gateways/:Id/tasks

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-gateways/:Id/tasks

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()

DELETE DeleteWirelessGatewayTaskDefinition

{{baseUrl}}/wireless-gateway-task-definitions/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-gateway-task-definitions/:Id

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()

PATCH DeregisterWirelessDevice

{{baseUrl}}/wireless-devices/:Identifier/deregister

QUERY PARAMS

Identifier

Examples

REQUEST

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

curl --request PATCH \
  --url {{baseUrl}}/wireless-devices/:Identifier/deregister

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()

DELETE DisassociateAwsAccountFromPartnerAccount

{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType

QUERY PARAMS

partnerType

PartnerAccountId

Examples

REQUEST

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

curl --request DELETE \
  --url '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

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()

DELETE DisassociateMulticastGroupFromFuotaTask

{{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId

QUERY PARAMS

MulticastGroupId

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/fuota-tasks/:Id/multicast-groups/:MulticastGroupId

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()

DELETE DisassociateWirelessDeviceFromFuotaTask

{{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId

QUERY PARAMS

WirelessDeviceId

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/fuota-tasks/:Id/wireless-devices/:WirelessDeviceId

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()

DELETE DisassociateWirelessDeviceFromMulticastGroup

{{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId

QUERY PARAMS

WirelessDeviceId

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/multicast-groups/:Id/wireless-devices/:WirelessDeviceId

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()

DELETE DisassociateWirelessDeviceFromThing

{{baseUrl}}/wireless-devices/:Id/thing

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-devices/:Id/thing

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()

DELETE DisassociateWirelessGatewayFromCertificate

{{baseUrl}}/wireless-gateways/:Id/certificate

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-gateways/:Id/certificate

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()

DELETE DisassociateWirelessGatewayFromThing

{{baseUrl}}/wireless-gateways/:Id/thing

QUERY PARAMS

Examples

REQUEST

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

curl --request DELETE \
  --url {{baseUrl}}/wireless-gateways/:Id/thing

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()

GET GetDestination

{{baseUrl}}/destinations/:Name

QUERY PARAMS

Name

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/destinations/:Name

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()

GET GetDeviceProfile

{{baseUrl}}/device-profiles/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/device-profiles/:Id

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()

GET GetEventConfigurationByResourceTypes

{{baseUrl}}/event-configurations-resource-types

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/event-configurations-resource-types

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()

GET GetFuotaTask

{{baseUrl}}/fuota-tasks/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/fuota-tasks/:Id

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()

GET GetLogLevelsByResourceTypes

{{baseUrl}}/log-levels

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/log-levels

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()

GET GetMulticastGroup

{{baseUrl}}/multicast-groups/:Id

QUERY PARAMS

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/multicast-groups/:Id

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()

GET GetMulticastGroupSession

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

QUERY PARAMS

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/multicast-groups/:Id/session

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()

GET GetNetworkAnalyzerConfiguration

{{baseUrl}}/network-analyzer-configurations/:ConfigurationName

QUERY PARAMS

ConfigurationName

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

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()

GET GetPartnerAccount

{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType

QUERY PARAMS

partnerType

PartnerAccountId

Examples

REQUEST

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

curl --request GET \
  --url '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

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()

GET GetPosition

{{baseUrl}}/positions/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

Examples

REQUEST

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

curl --request GET \
  --url '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType'

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()

GET GetPositionConfiguration

{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

Examples

REQUEST

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

curl --request GET \
  --url '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType'

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()

POST GetPositionEstimate

{{baseUrl}}/position-estimate

BODY json

{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}

Examples

REQUEST

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

curl --request POST \
  --url {{baseUrl}}/position-estimate \
  --header 'content-type: application/json' \
  --data '{
  "WiFiAccessPoints": [
    {
      "MacAddress": "",
      "Rss": ""
    }
  ],
  "CellTowers": {
    "Gsm": "",
    "Wcdma": "",
    "Tdscdma": "",
    "Lte": "",
    "Cdma": ""
  },
  "Ip": {
    "IpAddress": ""
  },
  "Gnss": {
    "Payload": "",
    "CaptureTime": "",
    "CaptureTimeAccuracy": "",
    "AssistPosition": "",
    "AssistAltitude": "",
    "Use2DSolver": ""
  },
  "Timestamp": ""
}'

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()

GET GetResourceEventConfiguration

{{baseUrl}}/event-configurations/:Identifier#identifierType

QUERY PARAMS

identifierType

Identifier

Examples

REQUEST

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

curl --request GET \
  --url '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType'

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()

GET GetResourceLogLevel

{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

Examples

REQUEST

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

curl --request GET \
  --url '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType'

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()

GET GetResourcePosition

{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

Examples

REQUEST

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

curl --request GET \
  --url '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType'

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()

GET GetServiceEndpoint

{{baseUrl}}/service-endpoint

Examples

REQUEST

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

curl --request GET \
  --url {{baseUrl}}/service-endpoint

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()

GET GetServiceProfile

{{baseUrl}}/service-profiles/:Id

QUERY PARAMS

Examples

REQUEST

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

import axios from 'axios';

const options = {method: 'GET', 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: '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-profiles/:Id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/service-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/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: 'GET', 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('GET', '{{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: 'GET', 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: '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-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}}/service-profiles/:Id" in

Client.call `GET 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 => "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-profiles/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/service-profiles/:Id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/service-profiles/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/service-profiles/:Id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-profiles/:Id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/service-profiles/:Id")

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

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

import requests

url = "{{baseUrl}}/service-profiles/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/service-profiles/:Id"

response <- VERB("GET", 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::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-profiles/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/service-profiles/:Id

http GET {{baseUrl}}/service-profiles/:Id

wget --quiet \
  --method GET \
  --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 = "GET"

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

dataTask.resume()

GET GetWirelessDevice

{{baseUrl}}/wireless-devices/:Identifier#identifierType

QUERY PARAMS

identifierType

Identifier

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Identifier?identifierType=#identifierType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-devices/:Identifier#identifierType" {:query-params {:identifierType ""}})

require "http/client"

url = "{{baseUrl}}/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/: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/wireless-devices/:Identifier?identifierType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/wireless-devices/:Identifier?identifierType=#identifierType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/: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}}/wireless-devices/:Identifier?identifierType=#identifierType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-devices/: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}}/wireless-devices/:Identifier?identifierType=#identifierType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless-devices/:Identifier#identifierType',
  params: {identifierType: ''}
};

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

const url = '{{baseUrl}}/wireless-devices/: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}}/wireless-devices/:Identifier?identifierType=#identifierType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/: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/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/: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}}/wireless-devices/:Identifier?identifierType=#identifierType" in

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

 "{{baseUrl}}/wireless-devices/: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}}/wireless-devices/:Identifier?identifierType=#identifierType');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Identifier#identifierType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'identifierType' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/wireless-devices/: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}}/wireless-devices/:Identifier?identifierType=#identifierType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Identifier?identifierType=#identifierType' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-devices/:Identifier?identifierType=")

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

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

import requests

url = "{{baseUrl}}/wireless-devices/:Identifier#identifierType"

querystring = {"identifierType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/: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}}/wireless-devices/: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/wireless-devices/:Identifier') do |req|
  req.params['identifierType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/: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);
}

curl --request GET \
  --url '{{baseUrl}}/wireless-devices/:Identifier?identifierType=#identifierType'

http GET '{{baseUrl}}/wireless-devices/:Identifier?identifierType=#identifierType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/wireless-devices/:Identifier?identifierType=#identifierType'

import Foundation

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

GET GetWirelessDeviceImportTask

{{baseUrl}}/wireless_device_import_task/:Id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
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/get "{{baseUrl}}/wireless_device_import_task/:Id")

require "http/client"

url = "{{baseUrl}}/wireless_device_import_task/: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}}/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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{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("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}}/wireless_device_import_task/:Id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{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('GET', '{{baseUrl}}/wireless_device_import_task/:Id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  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: '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}}/wireless_device_import_task/:Id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  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: 'GET',
  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('GET', '{{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: 'GET',
  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: '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}}/wireless_device_import_task/: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}}/wireless_device_import_task/:Id" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless_device_import_task/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_device_import_task/:Id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless_device_import_task/:Id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_device_import_task/:Id' -Method GET

import http.client

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

conn.request("GET", "/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.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless_device_import_task/:Id"

response <- VERB("GET", 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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless_device_import_task/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless_device_import_task/:Id

http GET {{baseUrl}}/wireless_device_import_task/:Id

wget --quiet \
  --method GET \
  --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 = "GET"

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

dataTask.resume()

GET GetWirelessDeviceStatistics

{{baseUrl}}/wireless-devices/:Id/statistics

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-devices/:Id/statistics")

require "http/client"

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

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}}/wireless-devices/:Id/statistics"),
};
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/statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-devices/:Id/statistics HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/statistics"))
    .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}}/wireless-devices/:Id/statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-devices/:Id/statistics")
  .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}}/wireless-devices/:Id/statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless-devices/:Id/statistics'
};

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

const url = '{{baseUrl}}/wireless-devices/:Id/statistics';
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}}/wireless-devices/:Id/statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/statistics")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-devices/:Id/statistics');

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}}/wireless-devices/:Id/statistics'
};

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/statistics';
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}}/wireless-devices/:Id/statistics"]
                                                       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}}/wireless-devices/:Id/statistics" in

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

 "{{baseUrl}}/wireless-devices/:Id/statistics",
  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}}/wireless-devices/:Id/statistics');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/wireless-devices/:Id/statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Id/statistics' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/statistics' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-devices/:Id/statistics")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-devices/:Id/statistics")

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/wireless-devices/:Id/statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/:Id/statistics";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-devices/:Id/statistics

http GET {{baseUrl}}/wireless-devices/:Id/statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id/statistics

import Foundation

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

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

dataTask.resume()

GET GetWirelessGateway

{{baseUrl}}/wireless-gateways/:Identifier#identifierType

QUERY PARAMS

identifierType

Identifier

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Identifier?identifierType=#identifierType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateways/:Identifier#identifierType" {:query-params {:identifierType ""}})

require "http/client"

url = "{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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/wireless-gateways/:Identifier?identifierType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/wireless-gateways/:Identifier?identifierType=#identifierType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Identifier?identifierType=#identifierType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Identifier?identifierType=#identifierType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless-gateways/:Identifier#identifierType',
  params: {identifierType: ''}
};

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

const url = '{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Identifier?identifierType=#identifierType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/: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/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/: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}}/wireless-gateways/:Identifier?identifierType=#identifierType" in

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

 "{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Identifier?identifierType=#identifierType');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Identifier#identifierType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'identifierType' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/:Identifier?identifierType=#identifierType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Identifier?identifierType=#identifierType' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-gateways/:Identifier?identifierType=")

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

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

import requests

url = "{{baseUrl}}/wireless-gateways/:Identifier#identifierType"

querystring = {"identifierType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/: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}}/wireless-gateways/: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/wireless-gateways/:Identifier') do |req|
  req.params['identifierType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/: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);
}

curl --request GET \
  --url '{{baseUrl}}/wireless-gateways/:Identifier?identifierType=#identifierType'

http GET '{{baseUrl}}/wireless-gateways/:Identifier?identifierType=#identifierType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/wireless-gateways/:Identifier?identifierType=#identifierType'

import Foundation

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

GET GetWirelessGatewayCertificate

{{baseUrl}}/wireless-gateways/:Id/certificate

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateways/:Id/certificate")

require "http/client"

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

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}}/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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-gateways/:Id/certificate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{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("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}}/wireless-gateways/:Id/certificate")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{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('GET', '{{baseUrl}}/wireless-gateways/:Id/certificate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  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: '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}}/wireless-gateways/:Id/certificate',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/certificate")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  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: 'GET',
  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('GET', '{{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: 'GET',
  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: '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}}/wireless-gateways/:Id/certificate"]
                                                       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}}/wireless-gateways/:Id/certificate" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless-gateways/:Id/certificate');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/certificate');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/certificate' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/certificate' -Method GET

import http.client

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

conn.request("GET", "/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.get(url)

print(response.json())

library(httr)

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

response <- VERB("GET", 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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless-gateways/:Id/certificate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/certificate";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateways/:Id/certificate

http GET {{baseUrl}}/wireless-gateways/:Id/certificate

wget --quiet \
  --method GET \
  --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 = "GET"

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

dataTask.resume()

GET GetWirelessGatewayFirmwareInformation

{{baseUrl}}/wireless-gateways/:Id/firmware-information

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id/firmware-information");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateways/:Id/firmware-information")

require "http/client"

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

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}}/wireless-gateways/:Id/firmware-information"),
};
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/firmware-information");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-gateways/:Id/firmware-information HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/wireless-gateways/:Id/firmware-information")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/firmware-information"))
    .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}}/wireless-gateways/:Id/firmware-information")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-gateways/:Id/firmware-information")
  .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}}/wireless-gateways/:Id/firmware-information');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless-gateways/:Id/firmware-information'
};

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

const url = '{{baseUrl}}/wireless-gateways/:Id/firmware-information';
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}}/wireless-gateways/:Id/firmware-information',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/firmware-information")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-gateways/:Id/firmware-information',
  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}}/wireless-gateways/:Id/firmware-information'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-gateways/:Id/firmware-information');

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}}/wireless-gateways/:Id/firmware-information'
};

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/firmware-information';
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}}/wireless-gateways/:Id/firmware-information"]
                                                       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}}/wireless-gateways/:Id/firmware-information" in

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

 "{{baseUrl}}/wireless-gateways/:Id/firmware-information",
  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}}/wireless-gateways/:Id/firmware-information');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id/firmware-information');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/firmware-information');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/firmware-information' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/firmware-information' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-gateways/:Id/firmware-information")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateways/:Id/firmware-information")

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/wireless-gateways/:Id/firmware-information') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/firmware-information";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateways/:Id/firmware-information

http GET {{baseUrl}}/wireless-gateways/:Id/firmware-information

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/firmware-information

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateways/:Id/firmware-information")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET GetWirelessGatewayStatistics

{{baseUrl}}/wireless-gateways/:Id/statistics

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateways/:Id/statistics")

require "http/client"

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

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}}/wireless-gateways/:Id/statistics"),
};
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/statistics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-gateways/:Id/statistics HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id/statistics"))
    .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}}/wireless-gateways/:Id/statistics")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-gateways/:Id/statistics")
  .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}}/wireless-gateways/:Id/statistics');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless-gateways/:Id/statistics'
};

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

const url = '{{baseUrl}}/wireless-gateways/:Id/statistics';
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}}/wireless-gateways/:Id/statistics',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/statistics")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-gateways/:Id/statistics');

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}}/wireless-gateways/:Id/statistics'
};

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/statistics';
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}}/wireless-gateways/:Id/statistics"]
                                                       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}}/wireless-gateways/:Id/statistics" in

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

 "{{baseUrl}}/wireless-gateways/:Id/statistics",
  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}}/wireless-gateways/:Id/statistics');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/statistics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/statistics' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/statistics' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-gateways/:Id/statistics")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-gateways/:Id/statistics")

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/wireless-gateways/:Id/statistics') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateways/:Id/statistics";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateways/:Id/statistics

http GET {{baseUrl}}/wireless-gateways/:Id/statistics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id/statistics

import Foundation

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

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

dataTask.resume()

GET GetWirelessGatewayTask

{{baseUrl}}/wireless-gateways/:Id/tasks

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateways/:Id/tasks")

require "http/client"

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

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}}/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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-gateways/:Id/tasks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{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("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}}/wireless-gateways/:Id/tasks")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{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('GET', '{{baseUrl}}/wireless-gateways/:Id/tasks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', 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: '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}}/wireless-gateways/:Id/tasks',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id/tasks")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  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: 'GET', 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('GET', '{{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: 'GET', 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: '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}}/wireless-gateways/:Id/tasks"]
                                                       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}}/wireless-gateways/:Id/tasks" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless-gateways/:Id/tasks');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/wireless-gateways/:Id/tasks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways/:Id/tasks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id/tasks' -Method GET

import http.client

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

conn.request("GET", "/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.get(url)

print(response.json())

library(httr)

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

response <- VERB("GET", 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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless-gateways/:Id/tasks') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateways/:Id/tasks

http GET {{baseUrl}}/wireless-gateways/:Id/tasks

wget --quiet \
  --method GET \
  --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 = "GET"

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

dataTask.resume()

GET GetWirelessGatewayTaskDefinition

{{baseUrl}}/wireless-gateway-task-definitions/:Id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
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/get "{{baseUrl}}/wireless-gateway-task-definitions/:Id")

require "http/client"

url = "{{baseUrl}}/wireless-gateway-task-definitions/: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}}/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.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateway-task-definitions/: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/wireless-gateway-task-definitions/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{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("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}}/wireless-gateway-task-definitions/:Id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{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('GET', '{{baseUrl}}/wireless-gateway-task-definitions/:Id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  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: '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}}/wireless-gateway-task-definitions/:Id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateway-task-definitions/:Id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  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: 'GET',
  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('GET', '{{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: 'GET',
  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: '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}}/wireless-gateway-task-definitions/: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}}/wireless-gateway-task-definitions/:Id" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless-gateway-task-definitions/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateway-task-definitions/:Id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/wireless-gateway-task-definitions/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateway-task-definitions/:Id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateway-task-definitions/:Id' -Method GET

import http.client

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

conn.request("GET", "/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.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateway-task-definitions/:Id"

response <- VERB("GET", 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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless-gateway-task-definitions/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateway-task-definitions/:Id";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateway-task-definitions/:Id

http GET {{baseUrl}}/wireless-gateway-task-definitions/:Id

wget --quiet \
  --method GET \
  --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 = "GET"

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

dataTask.resume()

GET ListDestinations

{{baseUrl}}/destinations

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/destinations")

require "http/client"

url = "{{baseUrl}}/destinations"

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"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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: '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"]
                                                       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" in

Client.call `GET 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 => "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');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/destinations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/destinations' -Method GET

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/destinations"

response = requests.get(url)

print(response.json())

library(httr)

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

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

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::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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/destinations

http GET {{baseUrl}}/destinations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/destinations

import Foundation

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

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

dataTask.resume()

GET ListDeviceProfiles

{{baseUrl}}/device-profiles

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/device-profiles")

require "http/client"

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

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"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/device-profiles")
  .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');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/device-profiles'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/device-profiles")
  .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',
  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'};

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

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

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: '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"]
                                                       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" in

Client.call `GET 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 => "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');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/device-profiles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/device-profiles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/device-profiles' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/device-profiles")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

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::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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/device-profiles

http GET {{baseUrl}}/device-profiles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/device-profiles

import Foundation

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

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

dataTask.resume()

GET ListDevicesForWirelessDeviceImportTask

{{baseUrl}}/wireless_device_import_task#id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless_device_import_task?id=#id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless_device_import_task#id" {:query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/wireless_device_import_task?id=#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}}/wireless_device_import_task?id=#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=#id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless_device_import_task?id=#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/wireless_device_import_task?id= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless_device_import_task?id=#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}}/wireless_device_import_task?id=#id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless_device_import_task?id=#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}}/wireless_device_import_task?id=#id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless_device_import_task#id',
  params: {id: ''}
};

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

const url = '{{baseUrl}}/wireless_device_import_task?id=#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}}/wireless_device_import_task?id=#id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless_device_import_task?id=#id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  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: 'GET',
  url: '{{baseUrl}}/wireless_device_import_task#id',
  qs: {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}}/wireless_device_import_task#id');

req.query({
  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}}/wireless_device_import_task#id',
  params: {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=#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}}/wireless_device_import_task?id=#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}}/wireless_device_import_task?id=#id" in

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

 "{{baseUrl}}/wireless_device_import_task?id=#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}}/wireless_device_import_task?id=#id');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_device_import_task#id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'id' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/wireless_device_import_task#id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless_device_import_task?id=#id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_device_import_task?id=#id' -Method GET

import http.client

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

conn.request("GET", "/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"

querystring = {"id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless_device_import_task#id"

queryString <- list(id = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless_device_import_task?id=#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/wireless_device_import_task') do |req|
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("id", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/wireless_device_import_task?id=#id'

http GET '{{baseUrl}}/wireless_device_import_task?id=#id'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/wireless_device_import_task?id=#id'

import Foundation

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

GET ListEventConfigurations

{{baseUrl}}/event-configurations#resourceType

QUERY PARAMS

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-configurations?resourceType=#resourceType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/event-configurations#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/event-configurations?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}}/event-configurations?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}}/event-configurations?resourceType=#resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/event-configurations?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/event-configurations?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event-configurations?resourceType=#resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-configurations?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}}/event-configurations?resourceType=#resourceType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/event-configurations?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}}/event-configurations?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/event-configurations#resourceType',
  params: {resourceType: ''}
};

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

const url = '{{baseUrl}}/event-configurations?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}}/event-configurations?resourceType=#resourceType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/event-configurations?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/event-configurations?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}}/event-configurations#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}}/event-configurations#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}}/event-configurations#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}}/event-configurations?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}}/event-configurations?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}}/event-configurations?resourceType=#resourceType" in

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

 "{{baseUrl}}/event-configurations?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}}/event-configurations?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/event-configurations#resourceType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceType' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/event-configurations#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}}/event-configurations?resourceType=#resourceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-configurations?resourceType=#resourceType' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/event-configurations?resourceType=")

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

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

import requests

url = "{{baseUrl}}/event-configurations#resourceType"

querystring = {"resourceType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-configurations#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}}/event-configurations?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/event-configurations') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/event-configurations#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);
}

curl --request GET \
  --url '{{baseUrl}}/event-configurations?resourceType=#resourceType'

http GET '{{baseUrl}}/event-configurations?resourceType=#resourceType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/event-configurations?resourceType=#resourceType'

import Foundation

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

GET ListFuotaTasks

{{baseUrl}}/fuota-tasks

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/fuota-tasks")

require "http/client"

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

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"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/fuota-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('GET', '{{baseUrl}}/fuota-tasks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/fuota-tasks'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks")
  .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',
  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'};

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

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

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: '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"]
                                                       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" in

Client.call `GET 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 => "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');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/fuota-tasks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/fuota-tasks")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

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::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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/fuota-tasks

http GET {{baseUrl}}/fuota-tasks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/fuota-tasks

import Foundation

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

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

dataTask.resume()

GET ListMulticastGroups

{{baseUrl}}/multicast-groups

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/multicast-groups")

require "http/client"

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

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/multicast-groups"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/multicast-groups HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/multicast-groups")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/multicast-groups');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/multicast-groups';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/multicast-groups',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

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: '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"]
                                                       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" in

Client.call `GET 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 => "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');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/multicast-groups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/multicast-groups")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

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::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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/multicast-groups

http GET {{baseUrl}}/multicast-groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/multicast-groups

import Foundation

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

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

dataTask.resume()

GET ListMulticastGroupsByFuotaTask

{{baseUrl}}/fuota-tasks/:Id/multicast-groups

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/fuota-tasks/:Id/multicast-groups")

require "http/client"

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

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/fuota-tasks/:Id/multicast-groups"),
};
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");
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/multicast-groups"

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

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

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

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

}

GET /baseUrl/fuota-tasks/:Id/multicast-groups HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/:Id/multicast-groups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id/multicast-groups")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/fuota-tasks/:Id/multicast-groups")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/fuota-tasks/:Id/multicast-groups');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-groups'
};

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

const url = '{{baseUrl}}/fuota-tasks/:Id/multicast-groups';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-groups',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-groups'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/fuota-tasks/:Id/multicast-groups');

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

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/fuota-tasks/:Id/multicast-groups'
};

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';
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/multicast-groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/fuota-tasks/:Id/multicast-groups" in

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

 "{{baseUrl}}/fuota-tasks/:Id/multicast-groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/fuota-tasks/:Id/multicast-groups');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks/:Id/multicast-groups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id/multicast-groups' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/fuota-tasks/:Id/multicast-groups")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fuota-tasks/:Id/multicast-groups")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/fuota-tasks/:Id/multicast-groups') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/fuota-tasks/:Id/multicast-groups

http GET {{baseUrl}}/fuota-tasks/:Id/multicast-groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id/multicast-groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id/multicast-groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET ListNetworkAnalyzerConfigurations

{{baseUrl}}/network-analyzer-configurations

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/network-analyzer-configurations")

require "http/client"

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

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"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/network-analyzer-configurations")
  .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');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/network-analyzer-configurations'
};

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

const url = '{{baseUrl}}/network-analyzer-configurations';
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',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations")
  .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',
  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'
};

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

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

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: '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"]
                                                       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" in

Client.call `GET 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 => "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');

echo $response->getBody();

setUrl('{{baseUrl}}/network-analyzer-configurations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/network-analyzer-configurations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/network-analyzer-configurations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/network-analyzer-configurations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/network-analyzer-configurations")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/network-analyzer-configurations"

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

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::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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/network-analyzer-configurations

http GET {{baseUrl}}/network-analyzer-configurations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/network-analyzer-configurations

import Foundation

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

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

dataTask.resume()

GET ListPartnerAccounts

{{baseUrl}}/partner-accounts

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/partner-accounts")

require "http/client"

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

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"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/partner-accounts")
  .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');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/partner-accounts'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/partner-accounts")
  .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',
  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'};

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

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

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: '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"]
                                                       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" in

Client.call `GET 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 => "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');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/partner-accounts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/partner-accounts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/partner-accounts' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/partner-accounts")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

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::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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/partner-accounts

http GET {{baseUrl}}/partner-accounts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/partner-accounts

import Foundation

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

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

dataTask.resume()

GET ListPositionConfigurations

{{baseUrl}}/position-configurations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/position-configurations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/position-configurations")

require "http/client"

url = "{{baseUrl}}/position-configurations"

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"),
};
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");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/position-configurations"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/position-configurations")
  .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');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/position-configurations'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/position-configurations")
  .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',
  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'};

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

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

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';
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"]
                                                       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" in

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

 "{{baseUrl}}/position-configurations",
  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');

echo $response->getBody();

setUrl('{{baseUrl}}/position-configurations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/position-configurations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/position-configurations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/position-configurations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/position-configurations")

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

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

import requests

url = "{{baseUrl}}/position-configurations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/position-configurations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/position-configurations")

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') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/position-configurations

http GET {{baseUrl}}/position-configurations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/position-configurations

import Foundation

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

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

dataTask.resume()

GET ListQueuedMessages

{{baseUrl}}/wireless-devices/:Id/data

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-devices/:Id/data")

require "http/client"

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

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}}/wireless-devices/:Id/data"),
};
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");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-devices/:Id/data HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/data"))
    .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}}/wireless-devices/:Id/data")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-devices/:Id/data")
  .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}}/wireless-devices/:Id/data');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/wireless-devices/:Id/data'};

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

const url = '{{baseUrl}}/wireless-devices/:Id/data';
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}}/wireless-devices/:Id/data',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/data")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-devices/:Id/data');

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}}/wireless-devices/:Id/data'};

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';
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}}/wireless-devices/:Id/data"]
                                                       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}}/wireless-devices/:Id/data" in

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

 "{{baseUrl}}/wireless-devices/:Id/data",
  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}}/wireless-devices/:Id/data');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/wireless-devices/:Id/data');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Id/data' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/data' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-devices/:Id/data")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-devices/:Id/data")

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/wireless-devices/:Id/data') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/:Id/data";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-devices/:Id/data

http GET {{baseUrl}}/wireless-devices/:Id/data

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id/data

import Foundation

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

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

dataTask.resume()

GET ListServiceProfiles

{{baseUrl}}/service-profiles

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/service-profiles")

require "http/client"

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

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"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/service-profiles")
  .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');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/service-profiles'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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-profiles');

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-profiles'};

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: '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-profiles"]
                                                       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-profiles" in

Client.call `GET 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 => "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-profiles');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/service-profiles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/service-profiles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-profiles' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/service-profiles")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

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::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-profiles') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/service-profiles

http GET {{baseUrl}}/service-profiles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/service-profiles

import Foundation

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

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

dataTask.resume()

GET ListTagsForResource

{{baseUrl}}/tags#resourceArn

QUERY PARAMS

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags?resourceArn=#resourceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tags#resourceArn" {:query-params {:resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/tags?resourceArn=#resourceArn"

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}}/tags?resourceArn=#resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags?resourceArn=#resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags?resourceArn=#resourceArn"

	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/tags?resourceArn= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags?resourceArn=#resourceArn"))
    .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}}/tags?resourceArn=#resourceArn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tags?resourceArn=#resourceArn")
  .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}}/tags?resourceArn=#resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tags#resourceArn',
  params: {resourceArn: ''}
};

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

const url = '{{baseUrl}}/tags?resourceArn=#resourceArn';
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}}/tags?resourceArn=#resourceArn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags?resourceArn=#resourceArn")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags?resourceArn=',
  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}}/tags#resourceArn',
  qs: {resourceArn: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags#resourceArn');

req.query({
  resourceArn: ''
});

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}}/tags#resourceArn',
  params: {resourceArn: ''}
};

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

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

const url = '{{baseUrl}}/tags?resourceArn=#resourceArn';
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}}/tags?resourceArn=#resourceArn"]
                                                       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}}/tags?resourceArn=#resourceArn" in

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

 "{{baseUrl}}/tags?resourceArn=#resourceArn",
  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}}/tags?resourceArn=#resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags#resourceArn');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resourceArn' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/tags#resourceArn');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resourceArn' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags?resourceArn=#resourceArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags?resourceArn=#resourceArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/tags?resourceArn=")

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

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

import requests

url = "{{baseUrl}}/tags#resourceArn"

querystring = {"resourceArn":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags#resourceArn"

queryString <- list(resourceArn = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags?resourceArn=#resourceArn")

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/tags') do |req|
  req.params['resourceArn'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("resourceArn", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/tags?resourceArn=#resourceArn'

http GET '{{baseUrl}}/tags?resourceArn=#resourceArn'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/tags?resourceArn=#resourceArn'

import Foundation

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

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

dataTask.resume()

GET ListWirelessDeviceImportTasks

{{baseUrl}}/wireless_device_import_tasks

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless_device_import_tasks")

require "http/client"

url = "{{baseUrl}}/wireless_device_import_tasks"

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}}/wireless_device_import_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_device_import_tasks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless_device_import_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('GET', '{{baseUrl}}/wireless_device_import_tasks');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless_device_import_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: 'GET', url: '{{baseUrl}}/wireless_device_import_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_device_import_tasks';
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}}/wireless_device_import_tasks"]
                                                       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}}/wireless_device_import_tasks" in

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

 "{{baseUrl}}/wireless_device_import_tasks",
  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}}/wireless_device_import_tasks');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_device_import_tasks');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless_device_import_tasks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_device_import_tasks' -Method GET

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/wireless_device_import_tasks"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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/wireless_device_import_tasks') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless_device_import_tasks

http GET {{baseUrl}}/wireless_device_import_tasks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless_device_import_tasks

import Foundation

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

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

dataTask.resume()

GET ListWirelessDevices

{{baseUrl}}/wireless-devices

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-devices")

require "http/client"

url = "{{baseUrl}}/wireless-devices"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/wireless-devices"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/wireless-devices HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-devices")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-devices")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/wireless-devices');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/wireless-devices'};

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

const url = '{{baseUrl}}/wireless-devices';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-devices',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/wireless-devices'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-devices');

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

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/wireless-devices'};

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: '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}}/wireless-devices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/wireless-devices" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless-devices');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/wireless-devices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-devices")

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

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

import requests

url = "{{baseUrl}}/wireless-devices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices"

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

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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless-devices') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-devices

http GET {{baseUrl}}/wireless-devices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-devices

import Foundation

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

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

dataTask.resume()

GET ListWirelessGatewayTaskDefinitions

{{baseUrl}}/wireless-gateway-task-definitions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateway-task-definitions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateway-task-definitions")

require "http/client"

url = "{{baseUrl}}/wireless-gateway-task-definitions"

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}}/wireless-gateway-task-definitions"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/wireless-gateway-task-definitions"

	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/wireless-gateway-task-definitions HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateway-task-definitions"))
    .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}}/wireless-gateway-task-definitions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-gateway-task-definitions")
  .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}}/wireless-gateway-task-definitions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wireless-gateway-task-definitions'
};

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: '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}}/wireless-gateway-task-definitions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateway-task-definitions")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-gateway-task-definitions');

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}}/wireless-gateway-task-definitions'
};

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: '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}}/wireless-gateway-task-definitions"]
                                                       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}}/wireless-gateway-task-definitions" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless-gateway-task-definitions');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateway-task-definitions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/wireless-gateway-task-definitions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateway-task-definitions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateway-task-definitions' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-gateway-task-definitions")

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

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

import requests

url = "{{baseUrl}}/wireless-gateway-task-definitions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateway-task-definitions"

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

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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless-gateway-task-definitions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-gateway-task-definitions";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateway-task-definitions

http GET {{baseUrl}}/wireless-gateway-task-definitions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-gateway-task-definitions

import Foundation

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

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

dataTask.resume()

GET ListWirelessGateways

{{baseUrl}}/wireless-gateways

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/wireless-gateways")

require "http/client"

url = "{{baseUrl}}/wireless-gateways"

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}}/wireless-gateways"),
};
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.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/wireless-gateways HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/wireless-gateways")
  .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}}/wireless-gateways');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/wireless-gateways'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wireless-gateways');

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

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: '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}}/wireless-gateways"]
                                                       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}}/wireless-gateways" in

Client.call `GET 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 => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/wireless-gateways');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/wireless-gateways');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-gateways' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/wireless-gateways")

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

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

import requests

url = "{{baseUrl}}/wireless-gateways"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways"

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

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::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/wireless-gateways') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/wireless-gateways

http GET {{baseUrl}}/wireless-gateways

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/wireless-gateways

import Foundation

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

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

dataTask.resume()

PUT PutPositionConfiguration

{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

BODY json

{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType");

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  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:Solvers {:SemtechGnss ""}
                                                                                                                  :Destination ""}})

require "http/client"

url = "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"),
    Content = new StringContent("{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\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-configurations/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"

	payload := strings.NewReader("{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\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/position-configurations/:ResourceIdentifier?resourceType= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\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  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .header("content-type", "application/json")
  .body("{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Solvers: {
    SemtechGnss: ''
  },
  Destination: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {Solvers: {SemtechGnss: ''}, Destination: ''}
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Solvers":{"SemtechGnss":""},"Destination":""}'
};

try {
  const response = await 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: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Solvers": {\n    "SemtechGnss": ""\n  },\n  "Destination": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")
  .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/position-configurations/:ResourceIdentifier?resourceType=',
  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({Solvers: {SemtechGnss: ''}, Destination: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  body: {Solvers: {SemtechGnss: ''}, Destination: ''},
  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}}/position-configurations/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

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

req.type('json');
req.send({
  Solvers: {
    SemtechGnss: ''
  },
  Destination: ''
});

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}}/position-configurations/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {Solvers: {SemtechGnss: ''}, Destination: ''}
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Solvers":{"SemtechGnss":""},"Destination":""}'
};

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 = @{ @"Solvers": @{ @"SemtechGnss": @"" },
                              @"Destination": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType"]
                                                       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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}" in

Client.call ~headers ~body `PUT 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 => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Solvers' => [
        'SemtechGnss' => ''
    ],
    'Destination' => ''
  ]),
  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}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType', [
  'body' => '{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'resourceType' => ''
]);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Solvers' => [
    'SemtechGnss' => ''
  ],
  'Destination' => ''
]));

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

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

append(json_encode([
  'Solvers' => [
    'SemtechGnss' => ''
  ],
  'Destination' => ''
]));
$request->setRequestUrl('{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$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-configurations/:ResourceIdentifier?resourceType=#resourceType' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}'

import http.client

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

payload = "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/position-configurations/:ResourceIdentifier?resourceType=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

payload = {
    "Solvers": { "SemtechGnss": "" },
    "Destination": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/position-configurations/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

payload <- "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\n}"

encode <- "json"

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

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::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\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/position-configurations/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
  req.body = "{\n  \"Solvers\": {\n    \"SemtechGnss\": \"\"\n  },\n  \"Destination\": \"\"\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}}/position-configurations/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let payload = json!({
        "Solvers": json!({"SemtechGnss": ""}),
        "Destination": ""
    });

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType' \
  --header 'content-type: application/json' \
  --data '{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}'

echo '{
  "Solvers": {
    "SemtechGnss": ""
  },
  "Destination": ""
}' |  \
  http PUT '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Solvers": {\n    "SemtechGnss": ""\n  },\n  "Destination": ""\n}' \
  --output-document \
  - '{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Solvers": ["SemtechGnss": ""],
  "Destination": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/position-configurations/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

PUT PutResourceLogLevel

{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

BODY json

{
  "LogLevel": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}
                                                                                       :content-type :json
                                                                                       :form-params {:LogLevel ""}})

require "http/client"

url = "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"LogLevel\": \"\"\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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"),
    Content = new StringContent("{\n  \"LogLevel\": \"\"\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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LogLevel\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"

	payload := strings.NewReader("{\n  \"LogLevel\": \"\"\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/log-levels/:ResourceIdentifier?resourceType= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "LogLevel": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LogLevel\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"LogLevel\": \"\"\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  \"LogLevel\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .header("content-type", "application/json")
  .body("{\n  \"LogLevel\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {LogLevel: ''}
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LogLevel":""}'
};

try {
  const response = await 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: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LogLevel": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"LogLevel\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .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/log-levels/:ResourceIdentifier?resourceType=',
  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({LogLevel: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  body: {LogLevel: ''},
  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}}/log-levels/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

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

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

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}}/log-levels/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {LogLevel: ''}
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LogLevel":""}'
};

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

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

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

Client.call ~headers ~body `PUT 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 => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'LogLevel' => ''
  ]),
  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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType', [
  'body' => '{
  "LogLevel": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'resourceType' => ''
]);

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

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

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

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

append(json_encode([
  'LogLevel' => ''
]));
$request->setRequestUrl('{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LogLevel": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LogLevel": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/log-levels/:ResourceIdentifier?resourceType=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

payload <- "{\n  \"LogLevel\": \"\"\n}"

encode <- "json"

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

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::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"LogLevel\": \"\"\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/log-levels/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
  req.body = "{\n  \"LogLevel\": \"\"\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}}/log-levels/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

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

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' \
  --header 'content-type: application/json' \
  --data '{
  "LogLevel": ""
}'

echo '{
  "LogLevel": ""
}' |  \
  http PUT '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "LogLevel": ""\n}' \
  --output-document \
  - '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

DELETE ResetAllResourceLogLevels

{{baseUrl}}/log-levels

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log-levels");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/log-levels")

require "http/client"

url = "{{baseUrl}}/log-levels"

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}}/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.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/log-levels"

	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/log-levels HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log-levels"))
    .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}}/log-levels")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{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('DELETE', '{{baseUrl}}/log-levels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', 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: '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}}/log-levels',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/log-levels")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  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: 'DELETE', 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('DELETE', '{{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: 'DELETE', 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: '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}}/log-levels"]
                                                       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}}/log-levels" in

Client.call `DELETE 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 => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/log-levels');

echo $response->getBody();

setUrl('{{baseUrl}}/log-levels');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/log-levels');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/log-levels' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/log-levels' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/log-levels")

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

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

import requests

url = "{{baseUrl}}/log-levels"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/log-levels"

response <- VERB("DELETE", 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::Delete.new(url)

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

require 'faraday'

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

response = conn.delete('/baseUrl/log-levels') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/log-levels

http DELETE {{baseUrl}}/log-levels

wget --quiet \
  --method DELETE \
  --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 = "DELETE"

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

dataTask.resume()

DELETE ResetResourceLogLevel

{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
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/delete "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}})

require "http/client"

url = "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"

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}}/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.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"

	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/log-levels/:ResourceIdentifier?resourceType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{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("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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{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('DELETE', '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  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: '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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  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: 'DELETE',
  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('DELETE', '{{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: 'DELETE',
  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: '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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType"]
                                                       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}}/log-levels/:ResourceIdentifier?resourceType=#resourceType" in

Client.call `DELETE 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 => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'resourceType' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType');
$request->setRequestMethod('DELETE');
$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 DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType' -Method DELETE

import http.client

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

conn.request("DELETE", "/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.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/log-levels/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

response <- VERB("DELETE", 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::Delete.new(url)

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

require 'faraday'

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

response = conn.delete('/baseUrl/log-levels/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
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.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType'

http DELETE '{{baseUrl}}/log-levels/:ResourceIdentifier?resourceType=#resourceType'

wget --quiet \
  --method DELETE \
  --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 = "DELETE"

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

dataTask.resume()

POST SendDataToMulticastGroup

{{baseUrl}}/multicast-groups/:Id/data

QUERY PARAMS

BODY json

{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/multicast-groups/:Id/data" {:content-type :json
                                                                      :form-params {:PayloadData ""
                                                                                    :WirelessMetadata {:LoRaWAN {:FPort 0}}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id/data"

	payload := strings.NewReader("{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\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/:Id/data HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/multicast-groups/:Id/data")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/:Id/data"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\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  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/data")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/multicast-groups/:Id/data")
  .header("content-type", "application/json")
  .body("{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  PayloadData: '',
  WirelessMetadata: {
    LoRaWAN: {
      FPort: 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}}/multicast-groups/:Id/data');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/multicast-groups/:Id/data',
  headers: {'content-type': 'application/json'},
  data: {PayloadData: '', WirelessMetadata: {LoRaWAN: {FPort: 0}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/:Id/data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PayloadData":"","WirelessMetadata":{"LoRaWAN":{"FPort":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}}/multicast-groups/:Id/data',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PayloadData": "",\n  "WirelessMetadata": {\n    "LoRaWAN": {\n      "FPort": 0\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  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/data")
  .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/:Id/data',
  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({PayloadData: '', WirelessMetadata: {LoRaWAN: {FPort: 0}}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/multicast-groups/:Id/data',
  headers: {'content-type': 'application/json'},
  body: {PayloadData: '', WirelessMetadata: {LoRaWAN: {FPort: 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}}/multicast-groups/:Id/data');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PayloadData: '',
  WirelessMetadata: {
    LoRaWAN: {
      FPort: 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}}/multicast-groups/:Id/data',
  headers: {'content-type': 'application/json'},
  data: {PayloadData: '', WirelessMetadata: {LoRaWAN: {FPort: 0}}}
};

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/data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PayloadData":"","WirelessMetadata":{"LoRaWAN":{"FPort":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 = @{ @"PayloadData": @"",
                              @"WirelessMetadata": @{ @"LoRaWAN": @{ @"FPort": @0 } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/multicast-groups/:Id/data"]
                                                       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/:Id/data" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/multicast-groups/:Id/data",
  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([
    'PayloadData' => '',
    'WirelessMetadata' => [
        'LoRaWAN' => [
                'FPort' => 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}}/multicast-groups/:Id/data', [
  'body' => '{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/data');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PayloadData' => '',
  'WirelessMetadata' => [
    'LoRaWAN' => [
        'FPort' => 0
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PayloadData' => '',
  'WirelessMetadata' => [
    'LoRaWAN' => [
        'FPort' => 0
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/multicast-groups/:Id/data');
$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/:Id/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/multicast-groups/:Id/data", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id/data"

payload = {
    "PayloadData": "",
    "WirelessMetadata": { "LoRaWAN": { "FPort": 0 } }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/data"

payload <- "{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\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/:Id/data")

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  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\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/:Id/data') do |req|
  req.body = "{\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": {\n      \"FPort\": 0\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/:Id/data";

    let payload = json!({
        "PayloadData": "",
        "WirelessMetadata": json!({"LoRaWAN": json!({"FPort": 0})})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/multicast-groups/:Id/data \
  --header 'content-type: application/json' \
  --data '{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}'

echo '{
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": {
      "FPort": 0
    }
  }
}' |  \
  http POST {{baseUrl}}/multicast-groups/:Id/data \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "PayloadData": "",\n  "WirelessMetadata": {\n    "LoRaWAN": {\n      "FPort": 0\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/data

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "PayloadData": "",
  "WirelessMetadata": ["LoRaWAN": ["FPort": 0]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SendDataToWirelessDevice

{{baseUrl}}/wireless-devices/:Id/data

QUERY PARAMS

BODY json

{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id/data");

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  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/wireless-devices/:Id/data" {:content-type :json
                                                                      :form-params {:TransmitMode 0
                                                                                    :PayloadData ""
                                                                                    :WirelessMetadata {:LoRaWAN ""
                                                                                                       :Sidewalk ""}}})

require "http/client"

url = "{{baseUrl}}/wireless-devices/:Id/data"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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/:Id/data"),
    Content = new StringContent("{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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/:Id/data");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-devices/:Id/data"

	payload := strings.NewReader("{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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/:Id/data HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 111

{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless-devices/:Id/data")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/data"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/data")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/wireless-devices/:Id/data")
  .header("content-type", "application/json")
  .body("{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  TransmitMode: 0,
  PayloadData: '',
  WirelessMetadata: {
    LoRaWAN: '',
    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}}/wireless-devices/:Id/data');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-devices/:Id/data',
  headers: {'content-type': 'application/json'},
  data: {
    TransmitMode: 0,
    PayloadData: '',
    WirelessMetadata: {LoRaWAN: '', Sidewalk: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-devices/:Id/data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TransmitMode":0,"PayloadData":"","WirelessMetadata":{"LoRaWAN":"","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}}/wireless-devices/:Id/data',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransmitMode": 0,\n  "PayloadData": "",\n  "WirelessMetadata": {\n    "LoRaWAN": "",\n    "Sidewalk": ""\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  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/data")
  .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/:Id/data',
  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({
  TransmitMode: 0,
  PayloadData: '',
  WirelessMetadata: {LoRaWAN: '', Sidewalk: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless-devices/:Id/data',
  headers: {'content-type': 'application/json'},
  body: {
    TransmitMode: 0,
    PayloadData: '',
    WirelessMetadata: {LoRaWAN: '', 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}}/wireless-devices/:Id/data');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TransmitMode: 0,
  PayloadData: '',
  WirelessMetadata: {
    LoRaWAN: '',
    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}}/wireless-devices/:Id/data',
  headers: {'content-type': 'application/json'},
  data: {
    TransmitMode: 0,
    PayloadData: '',
    WirelessMetadata: {LoRaWAN: '', Sidewalk: ''}
  }
};

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';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TransmitMode":0,"PayloadData":"","WirelessMetadata":{"LoRaWAN":"","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 = @{ @"TransmitMode": @0,
                              @"PayloadData": @"",
                              @"WirelessMetadata": @{ @"LoRaWAN": @"", @"Sidewalk": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-devices/:Id/data"]
                                                       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/:Id/data" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-devices/:Id/data",
  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([
    'TransmitMode' => 0,
    'PayloadData' => '',
    'WirelessMetadata' => [
        'LoRaWAN' => '',
        '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}}/wireless-devices/:Id/data', [
  'body' => '{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id/data');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TransmitMode' => 0,
  'PayloadData' => '',
  'WirelessMetadata' => [
    'LoRaWAN' => '',
    'Sidewalk' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TransmitMode' => 0,
  'PayloadData' => '',
  'WirelessMetadata' => [
    'LoRaWAN' => '',
    'Sidewalk' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/wireless-devices/:Id/data');
$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/:Id/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/wireless-devices/:Id/data", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-devices/:Id/data"

payload = {
    "TransmitMode": 0,
    "PayloadData": "",
    "WirelessMetadata": {
        "LoRaWAN": "",
        "Sidewalk": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id/data"

payload <- "{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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/:Id/data")

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  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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/:Id/data') do |req|
  req.body = "{\n  \"TransmitMode\": 0,\n  \"PayloadData\": \"\",\n  \"WirelessMetadata\": {\n    \"LoRaWAN\": \"\",\n    \"Sidewalk\": \"\"\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/:Id/data";

    let payload = json!({
        "TransmitMode": 0,
        "PayloadData": "",
        "WirelessMetadata": json!({
            "LoRaWAN": "",
            "Sidewalk": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/wireless-devices/:Id/data \
  --header 'content-type: application/json' \
  --data '{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}'

echo '{
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": {
    "LoRaWAN": "",
    "Sidewalk": ""
  }
}' |  \
  http POST {{baseUrl}}/wireless-devices/:Id/data \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "TransmitMode": 0,\n  "PayloadData": "",\n  "WirelessMetadata": {\n    "LoRaWAN": "",\n    "Sidewalk": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id/data

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "TransmitMode": 0,
  "PayloadData": "",
  "WirelessMetadata": [
    "LoRaWAN": "",
    "Sidewalk": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-devices/:Id/data")! 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()

PATCH StartBulkAssociateWirelessDeviceWithMulticastGroup

{{baseUrl}}/multicast-groups/:Id/bulk

QUERY PARAMS

BODY json

{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/bulk");

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  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/multicast-groups/:Id/bulk" {:content-type :json
                                                                       :form-params {:QueryString ""
                                                                                     :Tags [{:Key ""
                                                                                             :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/multicast-groups/:Id/bulk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/multicast-groups/:Id/bulk"),
    Content = new StringContent("{\n  \"QueryString\": \"\",\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/:Id/bulk");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QueryString\": \"\",\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/:Id/bulk"

	payload := strings.NewReader("{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/multicast-groups/:Id/bulk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/multicast-groups/:Id/bulk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QueryString\": \"\",\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/:Id/bulk"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"QueryString\": \"\",\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  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/bulk")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/multicast-groups/:Id/bulk")
  .header("content-type", "application/json")
  .body("{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  QueryString: '',
  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('PATCH', '{{baseUrl}}/multicast-groups/:Id/bulk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/multicast-groups/:Id/bulk',
  headers: {'content-type': 'application/json'},
  data: {QueryString: '', Tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/:Id/bulk';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"QueryString":"","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/:Id/bulk',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QueryString": "",\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  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/bulk")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/multicast-groups/:Id/bulk',
  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({QueryString: '', Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/multicast-groups/:Id/bulk',
  headers: {'content-type': 'application/json'},
  body: {QueryString: '', 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('PATCH', '{{baseUrl}}/multicast-groups/:Id/bulk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  QueryString: '',
  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: 'PATCH',
  url: '{{baseUrl}}/multicast-groups/:Id/bulk',
  headers: {'content-type': 'application/json'},
  data: {QueryString: '', 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/:Id/bulk';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"QueryString":"","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 = @{ @"QueryString": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/multicast-groups/:Id/bulk"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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/bulk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/multicast-groups/:Id/bulk",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'QueryString' => '',
    '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('PATCH', '{{baseUrl}}/multicast-groups/:Id/bulk', [
  'body' => '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/bulk');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QueryString' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'QueryString' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/multicast-groups/:Id/bulk');
$request->setRequestMethod('PATCH');
$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/bulk' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/bulk' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/multicast-groups/:Id/bulk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id/bulk"

payload = {
    "QueryString": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/bulk"

payload <- "{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/multicast-groups/:Id/bulk")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"QueryString\": \"\",\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.patch('/baseUrl/multicast-groups/:Id/bulk') do |req|
  req.body = "{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/multicast-groups/:Id/bulk";

    let payload = json!({
        "QueryString": "",
        "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.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/multicast-groups/:Id/bulk \
  --header 'content-type: application/json' \
  --data '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/multicast-groups/:Id/bulk \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "QueryString": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/bulk

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "QueryString": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/bulk")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartBulkDisassociateWirelessDeviceFromMulticastGroup

{{baseUrl}}/multicast-groups/:Id/bulk

QUERY PARAMS

BODY json

{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/bulk");

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  \"QueryString\": \"\",\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/:Id/bulk" {:content-type :json
                                                                      :form-params {:QueryString ""
                                                                                    :Tags [{:Key ""
                                                                                            :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/multicast-groups/:Id/bulk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"QueryString\": \"\",\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/:Id/bulk"),
    Content = new StringContent("{\n  \"QueryString\": \"\",\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/:Id/bulk");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QueryString\": \"\",\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/:Id/bulk"

	payload := strings.NewReader("{\n  \"QueryString\": \"\",\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/:Id/bulk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/multicast-groups/:Id/bulk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QueryString\": \"\",\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/:Id/bulk"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QueryString\": \"\",\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  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/bulk")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/multicast-groups/:Id/bulk")
  .header("content-type", "application/json")
  .body("{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  QueryString: '',
  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/:Id/bulk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/multicast-groups/:Id/bulk',
  headers: {'content-type': 'application/json'},
  data: {QueryString: '', Tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/:Id/bulk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"QueryString":"","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/:Id/bulk',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QueryString": "",\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  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/bulk")
  .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/:Id/bulk',
  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({QueryString: '', Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/multicast-groups/:Id/bulk',
  headers: {'content-type': 'application/json'},
  body: {QueryString: '', 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/:Id/bulk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  QueryString: '',
  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/:Id/bulk',
  headers: {'content-type': 'application/json'},
  data: {QueryString: '', 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/:Id/bulk';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"QueryString":"","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 = @{ @"QueryString": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/multicast-groups/:Id/bulk"]
                                                       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/:Id/bulk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"QueryString\": \"\",\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/:Id/bulk",
  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([
    'QueryString' => '',
    '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/:Id/bulk', [
  'body' => '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/bulk');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QueryString' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'QueryString' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/multicast-groups/:Id/bulk');
$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/:Id/bulk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/bulk' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"QueryString\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/multicast-groups/:Id/bulk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id/bulk"

payload = {
    "QueryString": "",
    "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/:Id/bulk"

payload <- "{\n  \"QueryString\": \"\",\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/:Id/bulk")

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  \"QueryString\": \"\",\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/:Id/bulk') do |req|
  req.body = "{\n  \"QueryString\": \"\",\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/:Id/bulk";

    let payload = json!({
        "QueryString": "",
        "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);
}

curl --request POST \
  --url {{baseUrl}}/multicast-groups/:Id/bulk \
  --header 'content-type: application/json' \
  --data '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "QueryString": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/multicast-groups/:Id/bulk \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "QueryString": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/bulk

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "QueryString": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/bulk")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT StartFuotaTask

{{baseUrl}}/fuota-tasks/:Id

QUERY PARAMS

BODY json

{
  "LoRaWAN": {
    "StartTime": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/fuota-tasks/:Id" {:content-type :json
                                                           :form-params {:LoRaWAN {:StartTime ""}}})

require "http/client"

url = "{{baseUrl}}/fuota-tasks/:Id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/fuota-tasks/:Id"),
    Content = new StringContent("{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\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}}/fuota-tasks/:Id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/fuota-tasks/:Id"

	payload := strings.NewReader("{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/fuota-tasks/:Id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "LoRaWAN": {
    "StartTime": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/fuota-tasks/:Id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fuota-tasks/:Id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\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  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/fuota-tasks/:Id")
  .header("content-type", "application/json")
  .body("{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  LoRaWAN: {
    StartTime: ''
  }
});

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');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fuota-tasks/:Id',
  headers: {'content-type': 'application/json'},
  data: {LoRaWAN: {StartTime: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/fuota-tasks/:Id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LoRaWAN":{"StartTime":""}}'
};

try {
  const response = await 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: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LoRaWAN": {\n    "StartTime": ""\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  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/fuota-tasks/:Id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({LoRaWAN: {StartTime: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fuota-tasks/:Id',
  headers: {'content-type': 'application/json'},
  body: {LoRaWAN: {StartTime: ''}},
  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');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  LoRaWAN: {
    StartTime: ''
  }
});

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',
  headers: {'content-type': 'application/json'},
  data: {LoRaWAN: {StartTime: ''}}
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LoRaWAN":{"StartTime":""}}'
};

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 = @{ @"LoRaWAN": @{ @"StartTime": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/fuota-tasks/:Id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/fuota-tasks/:Id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT 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 => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'LoRaWAN' => [
        'StartTime' => ''
    ]
  ]),
  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', [
  'body' => '{
  "LoRaWAN": {
    "StartTime": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LoRaWAN' => [
    'StartTime' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'LoRaWAN' => [
    'StartTime' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LoRaWAN": {
    "StartTime": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LoRaWAN": {
    "StartTime": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/fuota-tasks/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/fuota-tasks/:Id"

payload = { "LoRaWAN": { "StartTime": "" } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id"

payload <- "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fuota-tasks/:Id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/fuota-tasks/:Id') do |req|
  req.body = "{\n  \"LoRaWAN\": {\n    \"StartTime\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/fuota-tasks/:Id";

    let payload = json!({"LoRaWAN": json!({"StartTime": ""})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/fuota-tasks/:Id \
  --header 'content-type: application/json' \
  --data '{
  "LoRaWAN": {
    "StartTime": ""
  }
}'

echo '{
  "LoRaWAN": {
    "StartTime": ""
  }
}' |  \
  http PUT {{baseUrl}}/fuota-tasks/:Id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "LoRaWAN": {\n    "StartTime": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["LoRaWAN": ["StartTime": ""]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fuota-tasks/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT StartMulticastGroupSession

{{baseUrl}}/multicast-groups/:Id/session

QUERY PARAMS

BODY json

{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id/session");

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  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/multicast-groups/:Id/session" {:content-type :json
                                                                        :form-params {:LoRaWAN {:DlDr 0
                                                                                                :DlFreq 0
                                                                                                :SessionStartTime ""
                                                                                                :SessionTimeout 0
                                                                                                :PingSlotPeriod ""}}})

require "http/client"

url = "{{baseUrl}}/multicast-groups/:Id/session"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/multicast-groups/:Id/session"),
    Content = new StringContent("{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\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/:Id/session");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id/session"

	payload := strings.NewReader("{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/multicast-groups/:Id/session HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 132

{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/multicast-groups/:Id/session")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/:Id/session"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\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  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/session")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/multicast-groups/:Id/session")
  .header("content-type", "application/json")
  .body("{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  LoRaWAN: {
    DlDr: 0,
    DlFreq: 0,
    SessionStartTime: '',
    SessionTimeout: 0,
    PingSlotPeriod: ''
  }
});

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/session');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/multicast-groups/:Id/session',
  headers: {'content-type': 'application/json'},
  data: {
    LoRaWAN: {
      DlDr: 0,
      DlFreq: 0,
      SessionStartTime: '',
      SessionTimeout: 0,
      PingSlotPeriod: ''
    }
  }
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LoRaWAN":{"DlDr":0,"DlFreq":0,"SessionStartTime":"","SessionTimeout":0,"PingSlotPeriod":""}}'
};

try {
  const response = await 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: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LoRaWAN": {\n    "DlDr": 0,\n    "DlFreq": 0,\n    "SessionStartTime": "",\n    "SessionTimeout": 0,\n    "PingSlotPeriod": ""\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  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id/session")
  .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/session',
  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({
  LoRaWAN: {
    DlDr: 0,
    DlFreq: 0,
    SessionStartTime: '',
    SessionTimeout: 0,
    PingSlotPeriod: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/multicast-groups/:Id/session',
  headers: {'content-type': 'application/json'},
  body: {
    LoRaWAN: {
      DlDr: 0,
      DlFreq: 0,
      SessionStartTime: '',
      SessionTimeout: 0,
      PingSlotPeriod: ''
    }
  },
  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/session');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  LoRaWAN: {
    DlDr: 0,
    DlFreq: 0,
    SessionStartTime: '',
    SessionTimeout: 0,
    PingSlotPeriod: ''
  }
});

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/session',
  headers: {'content-type': 'application/json'},
  data: {
    LoRaWAN: {
      DlDr: 0,
      DlFreq: 0,
      SessionStartTime: '',
      SessionTimeout: 0,
      PingSlotPeriod: ''
    }
  }
};

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: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"LoRaWAN":{"DlDr":0,"DlFreq":0,"SessionStartTime":"","SessionTimeout":0,"PingSlotPeriod":""}}'
};

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 = @{ @"LoRaWAN": @{ @"DlDr": @0, @"DlFreq": @0, @"SessionStartTime": @"", @"SessionTimeout": @0, @"PingSlotPeriod": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/multicast-groups/:Id/session"]
                                                       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/session" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT 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 => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'LoRaWAN' => [
        'DlDr' => 0,
        'DlFreq' => 0,
        'SessionStartTime' => '',
        'SessionTimeout' => 0,
        'PingSlotPeriod' => ''
    ]
  ]),
  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/session', [
  'body' => '{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id/session');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LoRaWAN' => [
    'DlDr' => 0,
    'DlFreq' => 0,
    'SessionStartTime' => '',
    'SessionTimeout' => 0,
    'PingSlotPeriod' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'LoRaWAN' => [
    'DlDr' => 0,
    'DlFreq' => 0,
    'SessionStartTime' => '',
    'SessionTimeout' => 0,
    'PingSlotPeriod' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/multicast-groups/:Id/session');
$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/session' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id/session' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/multicast-groups/:Id/session", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id/session"

payload = { "LoRaWAN": {
        "DlDr": 0,
        "DlFreq": 0,
        "SessionStartTime": "",
        "SessionTimeout": 0,
        "PingSlotPeriod": ""
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id/session"

payload <- "{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/multicast-groups/:Id/session")

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  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/multicast-groups/:Id/session') do |req|
  req.body = "{\n  \"LoRaWAN\": {\n    \"DlDr\": 0,\n    \"DlFreq\": 0,\n    \"SessionStartTime\": \"\",\n    \"SessionTimeout\": 0,\n    \"PingSlotPeriod\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/multicast-groups/:Id/session";

    let payload = json!({"LoRaWAN": json!({
            "DlDr": 0,
            "DlFreq": 0,
            "SessionStartTime": "",
            "SessionTimeout": 0,
            "PingSlotPeriod": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/multicast-groups/:Id/session \
  --header 'content-type: application/json' \
  --data '{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}'

echo '{
  "LoRaWAN": {
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  }
}' |  \
  http PUT {{baseUrl}}/multicast-groups/:Id/session \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "LoRaWAN": {\n    "DlDr": 0,\n    "DlFreq": 0,\n    "SessionStartTime": "",\n    "SessionTimeout": 0,\n    "PingSlotPeriod": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id/session

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["LoRaWAN": [
    "DlDr": 0,
    "DlFreq": 0,
    "SessionStartTime": "",
    "SessionTimeout": 0,
    "PingSlotPeriod": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id/session")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartSingleWirelessDeviceImportTask

{{baseUrl}}/wireless_single_device_import_task

BODY json

{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless_single_device_import_task");

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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/wireless_single_device_import_task" {:content-type :json
                                                                               :form-params {:DestinationName ""
                                                                                             :ClientRequestToken ""
                                                                                             :DeviceName ""
                                                                                             :Tags [{:Key ""
                                                                                                     :Value ""}]
                                                                                             :Sidewalk {:SidewalkManufacturingSn ""}}})

require "http/client"

url = "{{baseUrl}}/wireless_single_device_import_task"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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_single_device_import_task"),
    Content = new StringContent("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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_single_device_import_task");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless_single_device_import_task"

	payload := strings.NewReader("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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_single_device_import_task HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 194

{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless_single_device_import_task")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless_single_device_import_task"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless_single_device_import_task")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/wireless_single_device_import_task")
  .header("content-type", "application/json")
  .body("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  DestinationName: '',
  ClientRequestToken: '',
  DeviceName: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Sidewalk: {
    SidewalkManufacturingSn: ''
  }
});

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_single_device_import_task');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless_single_device_import_task',
  headers: {'content-type': 'application/json'},
  data: {
    DestinationName: '',
    ClientRequestToken: '',
    DeviceName: '',
    Tags: [{Key: '', Value: ''}],
    Sidewalk: {SidewalkManufacturingSn: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless_single_device_import_task';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DestinationName":"","ClientRequestToken":"","DeviceName":"","Tags":[{"Key":"","Value":""}],"Sidewalk":{"SidewalkManufacturingSn":""}}'
};

try {
  const response = await 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_single_device_import_task',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DestinationName": "",\n  "ClientRequestToken": "",\n  "DeviceName": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Sidewalk": {\n    "SidewalkManufacturingSn": ""\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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless_single_device_import_task")
  .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_single_device_import_task',
  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({
  DestinationName: '',
  ClientRequestToken: '',
  DeviceName: '',
  Tags: [{Key: '', Value: ''}],
  Sidewalk: {SidewalkManufacturingSn: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless_single_device_import_task',
  headers: {'content-type': 'application/json'},
  body: {
    DestinationName: '',
    ClientRequestToken: '',
    DeviceName: '',
    Tags: [{Key: '', Value: ''}],
    Sidewalk: {SidewalkManufacturingSn: ''}
  },
  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_single_device_import_task');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DestinationName: '',
  ClientRequestToken: '',
  DeviceName: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Sidewalk: {
    SidewalkManufacturingSn: ''
  }
});

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_single_device_import_task',
  headers: {'content-type': 'application/json'},
  data: {
    DestinationName: '',
    ClientRequestToken: '',
    DeviceName: '',
    Tags: [{Key: '', Value: ''}],
    Sidewalk: {SidewalkManufacturingSn: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/wireless_single_device_import_task';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DestinationName":"","ClientRequestToken":"","DeviceName":"","Tags":[{"Key":"","Value":""}],"Sidewalk":{"SidewalkManufacturingSn":""}}'
};

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 = @{ @"DestinationName": @"",
                              @"ClientRequestToken": @"",
                              @"DeviceName": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"Sidewalk": @{ @"SidewalkManufacturingSn": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless_single_device_import_task"]
                                                       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_single_device_import_task" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless_single_device_import_task",
  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([
    'DestinationName' => '',
    'ClientRequestToken' => '',
    'DeviceName' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'Sidewalk' => [
        'SidewalkManufacturingSn' => ''
    ]
  ]),
  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_single_device_import_task', [
  'body' => '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_single_device_import_task');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DestinationName' => '',
  'ClientRequestToken' => '',
  'DeviceName' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Sidewalk' => [
    'SidewalkManufacturingSn' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DestinationName' => '',
  'ClientRequestToken' => '',
  'DeviceName' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Sidewalk' => [
    'SidewalkManufacturingSn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/wireless_single_device_import_task');
$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_single_device_import_task' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_single_device_import_task' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/wireless_single_device_import_task", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless_single_device_import_task"

payload = {
    "DestinationName": "",
    "ClientRequestToken": "",
    "DeviceName": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "Sidewalk": { "SidewalkManufacturingSn": "" }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless_single_device_import_task"

payload <- "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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_single_device_import_task")

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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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_single_device_import_task') do |req|
  req.body = "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"DeviceName\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"SidewalkManufacturingSn\": \"\"\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_single_device_import_task";

    let payload = json!({
        "DestinationName": "",
        "ClientRequestToken": "",
        "DeviceName": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "Sidewalk": json!({"SidewalkManufacturingSn": ""})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/wireless_single_device_import_task \
  --header 'content-type: application/json' \
  --data '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}'

echo '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "SidewalkManufacturingSn": ""
  }
}' |  \
  http POST {{baseUrl}}/wireless_single_device_import_task \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DestinationName": "",\n  "ClientRequestToken": "",\n  "DeviceName": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Sidewalk": {\n    "SidewalkManufacturingSn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/wireless_single_device_import_task

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DestinationName": "",
  "ClientRequestToken": "",
  "DeviceName": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "Sidewalk": ["SidewalkManufacturingSn": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless_single_device_import_task")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartWirelessDeviceImportTask

{{baseUrl}}/wireless_device_import_task

BODY json

{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless_device_import_task");

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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/wireless_device_import_task" {:content-type :json
                                                                        :form-params {:DestinationName ""
                                                                                      :ClientRequestToken ""
                                                                                      :Tags [{:Key ""
                                                                                              :Value ""}]
                                                                                      :Sidewalk {:DeviceCreationFile ""
                                                                                                 :Role ""}}})

require "http/client"

url = "{{baseUrl}}/wireless_device_import_task"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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_device_import_task"),
    Content = new StringContent("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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_device_import_task");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless_device_import_task"

	payload := strings.NewReader("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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_device_import_task HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 185

{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless_device_import_task")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless_device_import_task"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless_device_import_task")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/wireless_device_import_task")
  .header("content-type", "application/json")
  .body("{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  DestinationName: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Sidewalk: {
    DeviceCreationFile: '',
    Role: ''
  }
});

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_device_import_task');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless_device_import_task',
  headers: {'content-type': 'application/json'},
  data: {
    DestinationName: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}],
    Sidewalk: {DeviceCreationFile: '', Role: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless_device_import_task';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DestinationName":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}],"Sidewalk":{"DeviceCreationFile":"","Role":""}}'
};

try {
  const response = await 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',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DestinationName": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Sidewalk": {\n    "DeviceCreationFile": "",\n    "Role": ""\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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless_device_import_task")
  .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_device_import_task',
  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({
  DestinationName: '',
  ClientRequestToken: '',
  Tags: [{Key: '', Value: ''}],
  Sidewalk: {DeviceCreationFile: '', Role: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/wireless_device_import_task',
  headers: {'content-type': 'application/json'},
  body: {
    DestinationName: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}],
    Sidewalk: {DeviceCreationFile: '', Role: ''}
  },
  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_device_import_task');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DestinationName: '',
  ClientRequestToken: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  Sidewalk: {
    DeviceCreationFile: '',
    Role: ''
  }
});

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_device_import_task',
  headers: {'content-type': 'application/json'},
  data: {
    DestinationName: '',
    ClientRequestToken: '',
    Tags: [{Key: '', Value: ''}],
    Sidewalk: {DeviceCreationFile: '', Role: ''}
  }
};

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';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DestinationName":"","ClientRequestToken":"","Tags":[{"Key":"","Value":""}],"Sidewalk":{"DeviceCreationFile":"","Role":""}}'
};

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 = @{ @"DestinationName": @"",
                              @"ClientRequestToken": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"Sidewalk": @{ @"DeviceCreationFile": @"", @"Role": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless_device_import_task"]
                                                       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_device_import_task" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless_device_import_task",
  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([
    'DestinationName' => '',
    'ClientRequestToken' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'Sidewalk' => [
        'DeviceCreationFile' => '',
        'Role' => ''
    ]
  ]),
  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_device_import_task', [
  'body' => '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_device_import_task');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DestinationName' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Sidewalk' => [
    'DeviceCreationFile' => '',
    'Role' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DestinationName' => '',
  'ClientRequestToken' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'Sidewalk' => [
    'DeviceCreationFile' => '',
    'Role' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/wireless_device_import_task');
$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_device_import_task' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_device_import_task' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/wireless_device_import_task", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless_device_import_task"

payload = {
    "DestinationName": "",
    "ClientRequestToken": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "Sidewalk": {
        "DeviceCreationFile": "",
        "Role": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless_device_import_task"

payload <- "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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_device_import_task")

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  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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_device_import_task') do |req|
  req.body = "{\n  \"DestinationName\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\",\n    \"Role\": \"\"\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_device_import_task";

    let payload = json!({
        "DestinationName": "",
        "ClientRequestToken": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "Sidewalk": json!({
            "DeviceCreationFile": "",
            "Role": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/wireless_device_import_task \
  --header 'content-type: application/json' \
  --data '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}'

echo '{
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "Sidewalk": {
    "DeviceCreationFile": "",
    "Role": ""
  }
}' |  \
  http POST {{baseUrl}}/wireless_device_import_task \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DestinationName": "",\n  "ClientRequestToken": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "Sidewalk": {\n    "DeviceCreationFile": "",\n    "Role": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/wireless_device_import_task

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DestinationName": "",
  "ClientRequestToken": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "Sidewalk": [
    "DeviceCreationFile": "",
    "Role": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless_device_import_task")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/tags#resourceArn

QUERY PARAMS

resourceArn

BODY json

{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags?resourceArn=#resourceArn");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tags#resourceArn" {:query-params {:resourceArn ""}
                                                             :content-type :json
                                                             :form-params {:Tags [{:Key ""
                                                                                   :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/tags?resourceArn=#resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\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}}/tags?resourceArn=#resourceArn"),
    Content = new StringContent("{\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}}/tags?resourceArn=#resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\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}}/tags?resourceArn=#resourceArn"

	payload := strings.NewReader("{\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/tags?resourceArn= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tags?resourceArn=#resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\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}}/tags?resourceArn=#resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\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  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags?resourceArn=#resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tags?resourceArn=#resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  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}}/tags?resourceArn=#resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags#resourceArn',
  params: {resourceArn: ''},
  headers: {'content-type': 'application/json'},
  data: {Tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags?resourceArn=#resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/tags?resourceArn=#resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags?resourceArn=#resourceArn")
  .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/tags?resourceArn=',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags#resourceArn',
  qs: {resourceArn: ''},
  headers: {'content-type': 'application/json'},
  body: {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}}/tags#resourceArn');

req.query({
  resourceArn: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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}}/tags#resourceArn',
  params: {resourceArn: ''},
  headers: {'content-type': 'application/json'},
  data: {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}}/tags?resourceArn=#resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags?resourceArn=#resourceArn"]
                                                       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}}/tags?resourceArn=#resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\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}}/tags?resourceArn=#resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Tags' => [
        [
                '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}}/tags?resourceArn=#resourceArn', [
  'body' => '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags#resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'resourceArn' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags#resourceArn');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'resourceArn' => ''
]));

$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}}/tags?resourceArn=#resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags?resourceArn=#resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/tags?resourceArn=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags#resourceArn"

querystring = {"resourceArn":""}

payload = { "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags#resourceArn"

queryString <- list(resourceArn = "")

payload <- "{\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags?resourceArn=#resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Tags\": [\n    {\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/tags') do |req|
  req.params['resourceArn'] = ''
  req.body = "{\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}}/tags#resourceArn";

    let querystring = [
        ("resourceArn", ""),
    ];

    let payload = json!({"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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/tags?resourceArn=#resourceArn' \
  --header 'content-type: application/json' \
  --data '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/tags?resourceArn=#resourceArn' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/tags?resourceArn=#resourceArn'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags?resourceArn=#resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TestWirelessDevice

{{baseUrl}}/wireless-devices/:Id/test

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id/test");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/wireless-devices/:Id/test")

require "http/client"

url = "{{baseUrl}}/wireless-devices/:Id/test"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/wireless-devices/:Id/test"),
};
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/test");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-devices/:Id/test"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/wireless-devices/:Id/test HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/wireless-devices/:Id/test")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id/test"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/test")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/wireless-devices/:Id/test")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/wireless-devices/:Id/test');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/wireless-devices/:Id/test'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-devices/:Id/test';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/wireless-devices/:Id/test',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id/test")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-devices/:Id/test',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/wireless-devices/:Id/test'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/wireless-devices/:Id/test');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/wireless-devices/:Id/test'};

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/test';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-devices/:Id/test"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/wireless-devices/:Id/test" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/wireless-devices/:Id/test",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/wireless-devices/:Id/test');

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id/test');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/wireless-devices/:Id/test');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/wireless-devices/:Id/test' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id/test' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/wireless-devices/:Id/test")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-devices/:Id/test"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id/test"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wireless-devices/:Id/test")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/wireless-devices/:Id/test') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless-devices/:Id/test";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/wireless-devices/:Id/test

http POST {{baseUrl}}/wireless-devices/:Id/test

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id/test

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-devices/:Id/test")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE UntagResource

{{baseUrl}}/tags#resourceArn&tagKeys

QUERY PARAMS

resourceArn

tagKeys

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags#resourceArn&tagKeys" {:query-params {:resourceArn ""
                                                                                      :tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tags?resourceArn=&tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags#resourceArn&tagKeys',
  params: {resourceArn: '', tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags?resourceArn=&tagKeys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags#resourceArn&tagKeys',
  qs: {resourceArn: '', tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags#resourceArn&tagKeys');

req.query({
  resourceArn: '',
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags#resourceArn&tagKeys',
  params: {resourceArn: '', tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags#resourceArn&tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'resourceArn' => '',
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags#resourceArn&tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'resourceArn' => '',
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags?resourceArn=&tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags#resourceArn&tagKeys"

querystring = {"resourceArn":"","tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags#resourceArn&tagKeys"

queryString <- list(
  resourceArn = "",
  tagKeys = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tags') do |req|
  req.params['resourceArn'] = ''
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags#resourceArn&tagKeys";

    let querystring = [
        ("resourceArn", ""),
        ("tagKeys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys'

http DELETE '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags?resourceArn=&tagKeys=#resourceArn&tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateDestination

{{baseUrl}}/destinations/:Name

QUERY PARAMS

Name

BODY json

{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/destinations/:Name");

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  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/destinations/:Name" {:content-type :json
                                                                :form-params {:ExpressionType ""
                                                                              :Expression ""
                                                                              :Description ""
                                                                              :RoleArn ""}})

require "http/client"

url = "{{baseUrl}}/destinations/:Name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/destinations/:Name"),
    Content = new StringContent("{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/destinations/:Name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/destinations/:Name"

	payload := strings.NewReader("{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/destinations/:Name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/destinations/:Name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/destinations/:Name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/destinations/:Name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/destinations/:Name")
  .header("content-type", "application/json")
  .body("{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ExpressionType: '',
  Expression: '',
  Description: '',
  RoleArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/destinations/:Name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/destinations/:Name',
  headers: {'content-type': 'application/json'},
  data: {ExpressionType: '', Expression: '', Description: '', RoleArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/destinations/:Name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"ExpressionType":"","Expression":"","Description":"","RoleArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/destinations/:Name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ExpressionType": "",\n  "Expression": "",\n  "Description": "",\n  "RoleArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/destinations/:Name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/destinations/:Name',
  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({ExpressionType: '', Expression: '', Description: '', RoleArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/destinations/:Name',
  headers: {'content-type': 'application/json'},
  body: {ExpressionType: '', Expression: '', Description: '', RoleArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/destinations/:Name');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ExpressionType: '',
  Expression: '',
  Description: '',
  RoleArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/destinations/:Name',
  headers: {'content-type': 'application/json'},
  data: {ExpressionType: '', Expression: '', Description: '', RoleArn: ''}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"ExpressionType":"","Expression":"","Description":"","RoleArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ExpressionType": @"",
                              @"Expression": @"",
                              @"Description": @"",
                              @"RoleArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/destinations/:Name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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/:Name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'ExpressionType' => '',
    'Expression' => '',
    'Description' => '',
    'RoleArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/destinations/:Name', [
  'body' => '{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/destinations/:Name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ExpressionType' => '',
  'Expression' => '',
  'Description' => '',
  'RoleArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ExpressionType' => '',
  'Expression' => '',
  'Description' => '',
  'RoleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/destinations/:Name');
$request->setRequestMethod('PATCH');
$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/:Name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/destinations/:Name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/destinations/:Name", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/destinations/:Name"

payload = {
    "ExpressionType": "",
    "Expression": "",
    "Description": "",
    "RoleArn": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/destinations/:Name"

payload <- "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/destinations/:Name') do |req|
  req.body = "{\n  \"ExpressionType\": \"\",\n  \"Expression\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/destinations/:Name";

    let payload = json!({
        "ExpressionType": "",
        "Expression": "",
        "Description": "",
        "RoleArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/destinations/:Name \
  --header 'content-type: application/json' \
  --data '{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}'

echo '{
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
}' |  \
  http PATCH {{baseUrl}}/destinations/:Name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "ExpressionType": "",\n  "Expression": "",\n  "Description": "",\n  "RoleArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/destinations/:Name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ExpressionType": "",
  "Expression": "",
  "Description": "",
  "RoleArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/destinations/:Name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateEventConfigurationByResourceTypes

{{baseUrl}}/event-configurations-resource-types

BODY json

{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-configurations-resource-types");

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  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/event-configurations-resource-types" {:content-type :json
                                                                                 :form-params {:DeviceRegistrationState {:Sidewalk ""}
                                                                                               :Proximity {:Sidewalk ""}
                                                                                               :Join {:LoRaWAN ""}
                                                                                               :ConnectionStatus {:LoRaWAN ""}
                                                                                               :MessageDeliveryStatus {:Sidewalk {:WirelessDeviceEventTopic ""}}}})

require "http/client"

url = "{{baseUrl}}/event-configurations-resource-types"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/event-configurations-resource-types"),
    Content = new StringContent("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\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}}/event-configurations-resource-types");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/event-configurations-resource-types"

	payload := strings.NewReader("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/event-configurations-resource-types HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 275

{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/event-configurations-resource-types")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-configurations-resource-types"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\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  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/event-configurations-resource-types")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/event-configurations-resource-types")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  DeviceRegistrationState: {
    Sidewalk: ''
  },
  Proximity: {
    Sidewalk: ''
  },
  Join: {
    LoRaWAN: ''
  },
  ConnectionStatus: {
    LoRaWAN: ''
  },
  MessageDeliveryStatus: {
    Sidewalk: {
      WirelessDeviceEventTopic: ''
    }
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/event-configurations-resource-types');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/event-configurations-resource-types',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceRegistrationState: {Sidewalk: ''},
    Proximity: {Sidewalk: ''},
    Join: {LoRaWAN: ''},
    ConnectionStatus: {LoRaWAN: ''},
    MessageDeliveryStatus: {Sidewalk: {WirelessDeviceEventTopic: ''}}
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceRegistrationState":{"Sidewalk":""},"Proximity":{"Sidewalk":""},"Join":{"LoRaWAN":""},"ConnectionStatus":{"LoRaWAN":""},"MessageDeliveryStatus":{"Sidewalk":{"WirelessDeviceEventTopic":""}}}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceRegistrationState": {\n    "Sidewalk": ""\n  },\n  "Proximity": {\n    "Sidewalk": ""\n  },\n  "Join": {\n    "LoRaWAN": ""\n  },\n  "ConnectionStatus": {\n    "LoRaWAN": ""\n  },\n  "MessageDeliveryStatus": {\n    "Sidewalk": {\n      "WirelessDeviceEventTopic": ""\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  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/event-configurations-resource-types")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/event-configurations-resource-types',
  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({
  DeviceRegistrationState: {Sidewalk: ''},
  Proximity: {Sidewalk: ''},
  Join: {LoRaWAN: ''},
  ConnectionStatus: {LoRaWAN: ''},
  MessageDeliveryStatus: {Sidewalk: {WirelessDeviceEventTopic: ''}}
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/event-configurations-resource-types',
  headers: {'content-type': 'application/json'},
  body: {
    DeviceRegistrationState: {Sidewalk: ''},
    Proximity: {Sidewalk: ''},
    Join: {LoRaWAN: ''},
    ConnectionStatus: {LoRaWAN: ''},
    MessageDeliveryStatus: {Sidewalk: {WirelessDeviceEventTopic: ''}}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/event-configurations-resource-types');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DeviceRegistrationState: {
    Sidewalk: ''
  },
  Proximity: {
    Sidewalk: ''
  },
  Join: {
    LoRaWAN: ''
  },
  ConnectionStatus: {
    LoRaWAN: ''
  },
  MessageDeliveryStatus: {
    Sidewalk: {
      WirelessDeviceEventTopic: ''
    }
  }
});

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}}/event-configurations-resource-types',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceRegistrationState: {Sidewalk: ''},
    Proximity: {Sidewalk: ''},
    Join: {LoRaWAN: ''},
    ConnectionStatus: {LoRaWAN: ''},
    MessageDeliveryStatus: {Sidewalk: {WirelessDeviceEventTopic: ''}}
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceRegistrationState":{"Sidewalk":""},"Proximity":{"Sidewalk":""},"Join":{"LoRaWAN":""},"ConnectionStatus":{"LoRaWAN":""},"MessageDeliveryStatus":{"Sidewalk":{"WirelessDeviceEventTopic":""}}}'
};

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 = @{ @"DeviceRegistrationState": @{ @"Sidewalk": @"" },
                              @"Proximity": @{ @"Sidewalk": @"" },
                              @"Join": @{ @"LoRaWAN": @"" },
                              @"ConnectionStatus": @{ @"LoRaWAN": @"" },
                              @"MessageDeliveryStatus": @{ @"Sidewalk": @{ @"WirelessDeviceEventTopic": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event-configurations-resource-types"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/event-configurations-resource-types" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceRegistrationState' => [
        'Sidewalk' => ''
    ],
    'Proximity' => [
        'Sidewalk' => ''
    ],
    'Join' => [
        'LoRaWAN' => ''
    ],
    'ConnectionStatus' => [
        'LoRaWAN' => ''
    ],
    'MessageDeliveryStatus' => [
        'Sidewalk' => [
                'WirelessDeviceEventTopic' => ''
        ]
    ]
  ]),
  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('PATCH', '{{baseUrl}}/event-configurations-resource-types', [
  'body' => '{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/event-configurations-resource-types');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceRegistrationState' => [
    'Sidewalk' => ''
  ],
  'Proximity' => [
    'Sidewalk' => ''
  ],
  'Join' => [
    'LoRaWAN' => ''
  ],
  'ConnectionStatus' => [
    'LoRaWAN' => ''
  ],
  'MessageDeliveryStatus' => [
    'Sidewalk' => [
        'WirelessDeviceEventTopic' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DeviceRegistrationState' => [
    'Sidewalk' => ''
  ],
  'Proximity' => [
    'Sidewalk' => ''
  ],
  'Join' => [
    'LoRaWAN' => ''
  ],
  'ConnectionStatus' => [
    'LoRaWAN' => ''
  ],
  'MessageDeliveryStatus' => [
    'Sidewalk' => [
        'WirelessDeviceEventTopic' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/event-configurations-resource-types');
$request->setRequestMethod('PATCH');
$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}}/event-configurations-resource-types' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-configurations-resource-types' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/event-configurations-resource-types", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/event-configurations-resource-types"

payload = {
    "DeviceRegistrationState": { "Sidewalk": "" },
    "Proximity": { "Sidewalk": "" },
    "Join": { "LoRaWAN": "" },
    "ConnectionStatus": { "LoRaWAN": "" },
    "MessageDeliveryStatus": { "Sidewalk": { "WirelessDeviceEventTopic": "" } }
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-configurations-resource-types"

payload <- "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\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.patch('/baseUrl/event-configurations-resource-types') do |req|
  req.body = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"WirelessDeviceEventTopic\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/event-configurations-resource-types";

    let payload = json!({
        "DeviceRegistrationState": json!({"Sidewalk": ""}),
        "Proximity": json!({"Sidewalk": ""}),
        "Join": json!({"LoRaWAN": ""}),
        "ConnectionStatus": json!({"LoRaWAN": ""}),
        "MessageDeliveryStatus": json!({"Sidewalk": json!({"WirelessDeviceEventTopic": ""})})
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/event-configurations-resource-types \
  --header 'content-type: application/json' \
  --data '{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}'

echo '{
  "DeviceRegistrationState": {
    "Sidewalk": ""
  },
  "Proximity": {
    "Sidewalk": ""
  },
  "Join": {
    "LoRaWAN": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "WirelessDeviceEventTopic": ""
    }
  }
}' |  \
  http PATCH {{baseUrl}}/event-configurations-resource-types \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceRegistrationState": {\n    "Sidewalk": ""\n  },\n  "Proximity": {\n    "Sidewalk": ""\n  },\n  "Join": {\n    "LoRaWAN": ""\n  },\n  "ConnectionStatus": {\n    "LoRaWAN": ""\n  },\n  "MessageDeliveryStatus": {\n    "Sidewalk": {\n      "WirelessDeviceEventTopic": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/event-configurations-resource-types

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DeviceRegistrationState": ["Sidewalk": ""],
  "Proximity": ["Sidewalk": ""],
  "Join": ["LoRaWAN": ""],
  "ConnectionStatus": ["LoRaWAN": ""],
  "MessageDeliveryStatus": ["Sidewalk": ["WirelessDeviceEventTopic": ""]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event-configurations-resource-types")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateFuotaTask

{{baseUrl}}/fuota-tasks/:Id

QUERY PARAMS

BODY json

{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fuota-tasks/:Id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/fuota-tasks/:Id" {:content-type :json
                                                             :form-params {:Name ""
                                                                           :Description ""
                                                                           :LoRaWAN {:RfRegion ""}
                                                                           :FirmwareUpdateImage ""
                                                                           :FirmwareUpdateRole ""
                                                                           :RedundancyPercent 0
                                                                           :FragmentSizeBytes 0
                                                                           :FragmentIntervalMS 0}})

require "http/client"

url = "{{baseUrl}}/fuota-tasks/:Id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/fuota-tasks/:Id"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\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/:Id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\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/:Id"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/fuota-tasks/:Id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 212

{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/fuota-tasks/:Id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\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/:Id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\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  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/fuota-tasks/:Id")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  LoRaWAN: {
    RfRegion: ''
  },
  FirmwareUpdateImage: '',
  FirmwareUpdateRole: '',
  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('PATCH', '{{baseUrl}}/fuota-tasks/:Id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/fuota-tasks/:Id',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    LoRaWAN: {RfRegion: ''},
    FirmwareUpdateImage: '',
    FirmwareUpdateRole: '',
    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/:Id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LoRaWAN":{"RfRegion":""},"FirmwareUpdateImage":"","FirmwareUpdateRole":"","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/:Id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "RfRegion": ""\n  },\n  "FirmwareUpdateImage": "",\n  "FirmwareUpdateRole": "",\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  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/fuota-tasks/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/fuota-tasks/:Id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  Name: '',
  Description: '',
  LoRaWAN: {RfRegion: ''},
  FirmwareUpdateImage: '',
  FirmwareUpdateRole: '',
  RedundancyPercent: 0,
  FragmentSizeBytes: 0,
  FragmentIntervalMS: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/fuota-tasks/:Id',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    LoRaWAN: {RfRegion: ''},
    FirmwareUpdateImage: '',
    FirmwareUpdateRole: '',
    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('PATCH', '{{baseUrl}}/fuota-tasks/:Id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Description: '',
  LoRaWAN: {
    RfRegion: ''
  },
  FirmwareUpdateImage: '',
  FirmwareUpdateRole: '',
  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: 'PATCH',
  url: '{{baseUrl}}/fuota-tasks/:Id',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    LoRaWAN: {RfRegion: ''},
    FirmwareUpdateImage: '',
    FirmwareUpdateRole: '',
    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/:Id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LoRaWAN":{"RfRegion":""},"FirmwareUpdateImage":"","FirmwareUpdateRole":"","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": @"",
                              @"LoRaWAN": @{ @"RfRegion": @"" },
                              @"FirmwareUpdateImage": @"",
                              @"FirmwareUpdateRole": @"",
                              @"RedundancyPercent": @0,
                              @"FragmentSizeBytes": @0,
                              @"FragmentIntervalMS": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/fuota-tasks/:Id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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" 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    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'LoRaWAN' => [
        'RfRegion' => ''
    ],
    'FirmwareUpdateImage' => '',
    'FirmwareUpdateRole' => '',
    '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('PATCH', '{{baseUrl}}/fuota-tasks/:Id', [
  'body' => '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'RfRegion' => ''
  ],
  'FirmwareUpdateImage' => '',
  'FirmwareUpdateRole' => '',
  'RedundancyPercent' => 0,
  'FragmentSizeBytes' => 0,
  'FragmentIntervalMS' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'RfRegion' => ''
  ],
  'FirmwareUpdateImage' => '',
  'FirmwareUpdateRole' => '',
  'RedundancyPercent' => 0,
  'FragmentSizeBytes' => 0,
  'FragmentIntervalMS' => 0
]));
$request->setRequestUrl('{{baseUrl}}/fuota-tasks/:Id');
$request->setRequestMethod('PATCH');
$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' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/fuota-tasks/:Id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/fuota-tasks/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/fuota-tasks/:Id"

payload = {
    "Name": "",
    "Description": "",
    "LoRaWAN": { "RfRegion": "" },
    "FirmwareUpdateImage": "",
    "FirmwareUpdateRole": "",
    "RedundancyPercent": 0,
    "FragmentSizeBytes": 0,
    "FragmentIntervalMS": 0
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fuota-tasks/:Id"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\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.patch('/baseUrl/fuota-tasks/:Id') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\"\n  },\n  \"FirmwareUpdateImage\": \"\",\n  \"FirmwareUpdateRole\": \"\",\n  \"RedundancyPercent\": 0,\n  \"FragmentSizeBytes\": 0,\n  \"FragmentIntervalMS\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/fuota-tasks/:Id";

    let payload = json!({
        "Name": "",
        "Description": "",
        "LoRaWAN": json!({"RfRegion": ""}),
        "FirmwareUpdateImage": "",
        "FirmwareUpdateRole": "",
        "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.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/fuota-tasks/:Id \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}'

echo '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": ""
  },
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "RedundancyPercent": 0,
  "FragmentSizeBytes": 0,
  "FragmentIntervalMS": 0
}' |  \
  http PATCH {{baseUrl}}/fuota-tasks/:Id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "RfRegion": ""\n  },\n  "FirmwareUpdateImage": "",\n  "FirmwareUpdateRole": "",\n  "RedundancyPercent": 0,\n  "FragmentSizeBytes": 0,\n  "FragmentIntervalMS": 0\n}' \
  --output-document \
  - {{baseUrl}}/fuota-tasks/:Id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "LoRaWAN": ["RfRegion": ""],
  "FirmwareUpdateImage": "",
  "FirmwareUpdateRole": "",
  "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/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateLogLevelsByResourceTypes

{{baseUrl}}/log-levels

BODY json

{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log-levels");

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  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/log-levels" {:content-type :json
                                                       :form-params {:DefaultLogLevel ""
                                                                     :WirelessDeviceLogOptions [{:Type ""
                                                                                                 :LogLevel ""
                                                                                                 :Events [{:Event ""
                                                                                                           :LogLevel ""}]}]
                                                                     :WirelessGatewayLogOptions [{:Type ""
                                                                                                  :LogLevel ""
                                                                                                  :Events [{:Event ""
                                                                                                            :LogLevel ""}]}]}})

require "http/client"

url = "{{baseUrl}}/log-levels"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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}}/log-levels"),
    Content = new StringContent("{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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}}/log-levels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/log-levels"

	payload := strings.NewReader("{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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/log-levels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 394

{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/log-levels")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log-levels"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/log-levels")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/log-levels")
  .header("content-type", "application/json")
  .body("{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  DefaultLogLevel: '',
  WirelessDeviceLogOptions: [
    {
      Type: '',
      LogLevel: '',
      Events: [
        {
          Event: '',
          LogLevel: ''
        }
      ]
    }
  ],
  WirelessGatewayLogOptions: [
    {
      Type: '',
      LogLevel: '',
      Events: [
        {
          Event: '',
          LogLevel: ''
        }
      ]
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/log-levels');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/log-levels',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultLogLevel: '',
    WirelessDeviceLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}],
    WirelessGatewayLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/log-levels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultLogLevel":"","WirelessDeviceLogOptions":[{"Type":"","LogLevel":"","Events":[{"Event":"","LogLevel":""}]}],"WirelessGatewayLogOptions":[{"Type":"","LogLevel":"","Events":[{"Event":"","LogLevel":""}]}]}'
};

try {
  const response = await 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: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DefaultLogLevel": "",\n  "WirelessDeviceLogOptions": [\n    {\n      "Type": "",\n      "LogLevel": "",\n      "Events": [\n        {\n          "Event": "",\n          "LogLevel": ""\n        }\n      ]\n    }\n  ],\n  "WirelessGatewayLogOptions": [\n    {\n      "Type": "",\n      "LogLevel": "",\n      "Events": [\n        {\n          "Event": "",\n          "LogLevel": ""\n        }\n      ]\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  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/log-levels")
  .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/log-levels',
  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({
  DefaultLogLevel: '',
  WirelessDeviceLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}],
  WirelessGatewayLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/log-levels',
  headers: {'content-type': 'application/json'},
  body: {
    DefaultLogLevel: '',
    WirelessDeviceLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}],
    WirelessGatewayLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}]
  },
  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}}/log-levels');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DefaultLogLevel: '',
  WirelessDeviceLogOptions: [
    {
      Type: '',
      LogLevel: '',
      Events: [
        {
          Event: '',
          LogLevel: ''
        }
      ]
    }
  ],
  WirelessGatewayLogOptions: [
    {
      Type: '',
      LogLevel: '',
      Events: [
        {
          Event: '',
          LogLevel: ''
        }
      ]
    }
  ]
});

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}}/log-levels',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultLogLevel: '',
    WirelessDeviceLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}],
    WirelessGatewayLogOptions: [{Type: '', LogLevel: '', Events: [{Event: '', LogLevel: ''}]}]
  }
};

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: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultLogLevel":"","WirelessDeviceLogOptions":[{"Type":"","LogLevel":"","Events":[{"Event":"","LogLevel":""}]}],"WirelessGatewayLogOptions":[{"Type":"","LogLevel":"","Events":[{"Event":"","LogLevel":""}]}]}'
};

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 = @{ @"DefaultLogLevel": @"",
                              @"WirelessDeviceLogOptions": @[ @{ @"Type": @"", @"LogLevel": @"", @"Events": @[ @{ @"Event": @"", @"LogLevel": @"" } ] } ],
                              @"WirelessGatewayLogOptions": @[ @{ @"Type": @"", @"LogLevel": @"", @"Events": @[ @{ @"Event": @"", @"LogLevel": @"" } ] } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/log-levels"]
                                                       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}}/log-levels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}" in

Client.call ~headers ~body `POST 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 => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DefaultLogLevel' => '',
    'WirelessDeviceLogOptions' => [
        [
                'Type' => '',
                'LogLevel' => '',
                'Events' => [
                                [
                                                                'Event' => '',
                                                                'LogLevel' => ''
                                ]
                ]
        ]
    ],
    'WirelessGatewayLogOptions' => [
        [
                'Type' => '',
                'LogLevel' => '',
                'Events' => [
                                [
                                                                'Event' => '',
                                                                'LogLevel' => ''
                                ]
                ]
        ]
    ]
  ]),
  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}}/log-levels', [
  'body' => '{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/log-levels');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DefaultLogLevel' => '',
  'WirelessDeviceLogOptions' => [
    [
        'Type' => '',
        'LogLevel' => '',
        'Events' => [
                [
                                'Event' => '',
                                'LogLevel' => ''
                ]
        ]
    ]
  ],
  'WirelessGatewayLogOptions' => [
    [
        'Type' => '',
        'LogLevel' => '',
        'Events' => [
                [
                                'Event' => '',
                                'LogLevel' => ''
                ]
        ]
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DefaultLogLevel' => '',
  'WirelessDeviceLogOptions' => [
    [
        'Type' => '',
        'LogLevel' => '',
        'Events' => [
                [
                                'Event' => '',
                                'LogLevel' => ''
                ]
        ]
    ]
  ],
  'WirelessGatewayLogOptions' => [
    [
        'Type' => '',
        'LogLevel' => '',
        'Events' => [
                [
                                'Event' => '',
                                'LogLevel' => ''
                ]
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/log-levels');
$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}}/log-levels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/log-levels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/log-levels", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/log-levels"

payload = {
    "DefaultLogLevel": "",
    "WirelessDeviceLogOptions": [
        {
            "Type": "",
            "LogLevel": "",
            "Events": [
                {
                    "Event": "",
                    "LogLevel": ""
                }
            ]
        }
    ],
    "WirelessGatewayLogOptions": [
        {
            "Type": "",
            "LogLevel": "",
            "Events": [
                {
                    "Event": "",
                    "LogLevel": ""
                }
            ]
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/log-levels"

payload <- "{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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}}/log-levels")

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  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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/log-levels') do |req|
  req.body = "{\n  \"DefaultLogLevel\": \"\",\n  \"WirelessDeviceLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\n    }\n  ],\n  \"WirelessGatewayLogOptions\": [\n    {\n      \"Type\": \"\",\n      \"LogLevel\": \"\",\n      \"Events\": [\n        {\n          \"Event\": \"\",\n          \"LogLevel\": \"\"\n        }\n      ]\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}}/log-levels";

    let payload = json!({
        "DefaultLogLevel": "",
        "WirelessDeviceLogOptions": (
            json!({
                "Type": "",
                "LogLevel": "",
                "Events": (
                    json!({
                        "Event": "",
                        "LogLevel": ""
                    })
                )
            })
        ),
        "WirelessGatewayLogOptions": (
            json!({
                "Type": "",
                "LogLevel": "",
                "Events": (
                    json!({
                        "Event": "",
                        "LogLevel": ""
                    })
                )
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/log-levels \
  --header 'content-type: application/json' \
  --data '{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}'

echo '{
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ],
  "WirelessGatewayLogOptions": [
    {
      "Type": "",
      "LogLevel": "",
      "Events": [
        {
          "Event": "",
          "LogLevel": ""
        }
      ]
    }
  ]
}' |  \
  http POST {{baseUrl}}/log-levels \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DefaultLogLevel": "",\n  "WirelessDeviceLogOptions": [\n    {\n      "Type": "",\n      "LogLevel": "",\n      "Events": [\n        {\n          "Event": "",\n          "LogLevel": ""\n        }\n      ]\n    }\n  ],\n  "WirelessGatewayLogOptions": [\n    {\n      "Type": "",\n      "LogLevel": "",\n      "Events": [\n        {\n          "Event": "",\n          "LogLevel": ""\n        }\n      ]\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/log-levels

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DefaultLogLevel": "",
  "WirelessDeviceLogOptions": [
    [
      "Type": "",
      "LogLevel": "",
      "Events": [
        [
          "Event": "",
          "LogLevel": ""
        ]
      ]
    ]
  ],
  "WirelessGatewayLogOptions": [
    [
      "Type": "",
      "LogLevel": "",
      "Events": [
        [
          "Event": "",
          "LogLevel": ""
        ]
      ]
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log-levels")! 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()

PATCH UpdateMulticastGroup

{{baseUrl}}/multicast-groups/:Id

QUERY PARAMS

BODY json

{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/multicast-groups/:Id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/multicast-groups/:Id" {:content-type :json
                                                                  :form-params {:Name ""
                                                                                :Description ""
                                                                                :LoRaWAN {:RfRegion ""
                                                                                          :DlClass ""}}})

require "http/client"

url = "{{baseUrl}}/multicast-groups/:Id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/multicast-groups/:Id"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\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/:Id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/multicast-groups/:Id"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/multicast-groups/:Id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 95

{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/multicast-groups/:Id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/multicast-groups/:Id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\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  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/multicast-groups/:Id")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  LoRaWAN: {
    RfRegion: '',
    DlClass: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/multicast-groups/:Id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/multicast-groups/:Id',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', LoRaWAN: {RfRegion: '', DlClass: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/multicast-groups/:Id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LoRaWAN":{"RfRegion":"","DlClass":""}}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "RfRegion": "",\n    "DlClass": ""\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  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/multicast-groups/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/multicast-groups/:Id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', Description: '', LoRaWAN: {RfRegion: '', DlClass: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/multicast-groups/:Id',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', LoRaWAN: {RfRegion: '', DlClass: ''}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/multicast-groups/:Id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Description: '',
  LoRaWAN: {
    RfRegion: '',
    DlClass: ''
  }
});

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}}/multicast-groups/:Id',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', LoRaWAN: {RfRegion: '', DlClass: ''}}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LoRaWAN":{"RfRegion":"","DlClass":""}}'
};

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": @{ @"RfRegion": @"", @"DlClass": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/multicast-groups/:Id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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" 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    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'LoRaWAN' => [
        'RfRegion' => '',
        'DlClass' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/multicast-groups/:Id', [
  'body' => '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/multicast-groups/:Id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'RfRegion' => '',
    'DlClass' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'RfRegion' => '',
    'DlClass' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/multicast-groups/:Id');
$request->setRequestMethod('PATCH');
$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' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/multicast-groups/:Id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/multicast-groups/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/multicast-groups/:Id"

payload = {
    "Name": "",
    "Description": "",
    "LoRaWAN": {
        "RfRegion": "",
        "DlClass": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/multicast-groups/:Id"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\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.patch('/baseUrl/multicast-groups/:Id') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"RfRegion\": \"\",\n    \"DlClass\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/multicast-groups/:Id";

    let payload = json!({
        "Name": "",
        "Description": "",
        "LoRaWAN": json!({
            "RfRegion": "",
            "DlClass": ""
        })
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/multicast-groups/:Id \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}'

echo '{
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "RfRegion": "",
    "DlClass": ""
  }
}' |  \
  http PATCH {{baseUrl}}/multicast-groups/:Id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "RfRegion": "",\n    "DlClass": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/multicast-groups/:Id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "LoRaWAN": [
    "RfRegion": "",
    "DlClass": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/multicast-groups/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateNetworkAnalyzerConfiguration

{{baseUrl}}/network-analyzer-configurations/:ConfigurationName

QUERY PARAMS

ConfigurationName

BODY json

{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName");

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  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName" {:content-type :json
                                                                                                :form-params {:TraceContent {:WirelessDeviceFrameInfo ""
                                                                                                                             :LogLevel ""}
                                                                                                              :WirelessDevicesToAdd []
                                                                                                              :WirelessDevicesToRemove []
                                                                                                              :WirelessGatewaysToAdd []
                                                                                                              :WirelessGatewaysToRemove []
                                                                                                              :Description ""}})

require "http/client"

url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"),
    Content = new StringContent("{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\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/:ConfigurationName");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

	payload := strings.NewReader("{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/network-analyzer-configurations/:ConfigurationName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 230

{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\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  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .header("content-type", "application/json")
  .body("{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TraceContent: {
    WirelessDeviceFrameInfo: '',
    LogLevel: ''
  },
  WirelessDevicesToAdd: [],
  WirelessDevicesToRemove: [],
  WirelessGatewaysToAdd: [],
  WirelessGatewaysToRemove: [],
  Description: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName',
  headers: {'content-type': 'application/json'},
  data: {
    TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
    WirelessDevicesToAdd: [],
    WirelessDevicesToRemove: [],
    WirelessGatewaysToAdd: [],
    WirelessGatewaysToRemove: [],
    Description: ''
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"TraceContent":{"WirelessDeviceFrameInfo":"","LogLevel":""},"WirelessDevicesToAdd":[],"WirelessDevicesToRemove":[],"WirelessGatewaysToAdd":[],"WirelessGatewaysToRemove":[],"Description":""}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TraceContent": {\n    "WirelessDeviceFrameInfo": "",\n    "LogLevel": ""\n  },\n  "WirelessDevicesToAdd": [],\n  "WirelessDevicesToRemove": [],\n  "WirelessGatewaysToAdd": [],\n  "WirelessGatewaysToRemove": [],\n  "Description": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/network-analyzer-configurations/:ConfigurationName',
  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({
  TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
  WirelessDevicesToAdd: [],
  WirelessDevicesToRemove: [],
  WirelessGatewaysToAdd: [],
  WirelessGatewaysToRemove: [],
  Description: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName',
  headers: {'content-type': 'application/json'},
  body: {
    TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
    WirelessDevicesToAdd: [],
    WirelessDevicesToRemove: [],
    WirelessGatewaysToAdd: [],
    WirelessGatewaysToRemove: [],
    Description: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TraceContent: {
    WirelessDeviceFrameInfo: '',
    LogLevel: ''
  },
  WirelessDevicesToAdd: [],
  WirelessDevicesToRemove: [],
  WirelessGatewaysToAdd: [],
  WirelessGatewaysToRemove: [],
  Description: ''
});

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}}/network-analyzer-configurations/:ConfigurationName',
  headers: {'content-type': 'application/json'},
  data: {
    TraceContent: {WirelessDeviceFrameInfo: '', LogLevel: ''},
    WirelessDevicesToAdd: [],
    WirelessDevicesToRemove: [],
    WirelessGatewaysToAdd: [],
    WirelessGatewaysToRemove: [],
    Description: ''
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"TraceContent":{"WirelessDeviceFrameInfo":"","LogLevel":""},"WirelessDevicesToAdd":[],"WirelessDevicesToRemove":[],"WirelessGatewaysToAdd":[],"WirelessGatewaysToRemove":[],"Description":""}'
};

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 = @{ @"TraceContent": @{ @"WirelessDeviceFrameInfo": @"", @"LogLevel": @"" },
                              @"WirelessDevicesToAdd": @[  ],
                              @"WirelessDevicesToRemove": @[  ],
                              @"WirelessGatewaysToAdd": @[  ],
                              @"WirelessGatewaysToRemove": @[  ],
                              @"Description": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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/:ConfigurationName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'TraceContent' => [
        'WirelessDeviceFrameInfo' => '',
        'LogLevel' => ''
    ],
    'WirelessDevicesToAdd' => [
        
    ],
    'WirelessDevicesToRemove' => [
        
    ],
    'WirelessGatewaysToAdd' => [
        
    ],
    'WirelessGatewaysToRemove' => [
        
    ],
    'Description' => ''
  ]),
  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('PATCH', '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName', [
  'body' => '{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TraceContent' => [
    'WirelessDeviceFrameInfo' => '',
    'LogLevel' => ''
  ],
  'WirelessDevicesToAdd' => [
    
  ],
  'WirelessDevicesToRemove' => [
    
  ],
  'WirelessGatewaysToAdd' => [
    
  ],
  'WirelessGatewaysToRemove' => [
    
  ],
  'Description' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TraceContent' => [
    'WirelessDeviceFrameInfo' => '',
    'LogLevel' => ''
  ],
  'WirelessDevicesToAdd' => [
    
  ],
  'WirelessDevicesToRemove' => [
    
  ],
  'WirelessGatewaysToAdd' => [
    
  ],
  'WirelessGatewaysToRemove' => [
    
  ],
  'Description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/network-analyzer-configurations/:ConfigurationName');
$request->setRequestMethod('PATCH');
$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/:ConfigurationName' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/network-analyzer-configurations/:ConfigurationName' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/network-analyzer-configurations/:ConfigurationName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

payload = {
    "TraceContent": {
        "WirelessDeviceFrameInfo": "",
        "LogLevel": ""
    },
    "WirelessDevicesToAdd": [],
    "WirelessDevicesToRemove": [],
    "WirelessGatewaysToAdd": [],
    "WirelessGatewaysToRemove": [],
    "Description": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName"

payload <- "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\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.patch('/baseUrl/network-analyzer-configurations/:ConfigurationName') do |req|
  req.body = "{\n  \"TraceContent\": {\n    \"WirelessDeviceFrameInfo\": \"\",\n    \"LogLevel\": \"\"\n  },\n  \"WirelessDevicesToAdd\": [],\n  \"WirelessDevicesToRemove\": [],\n  \"WirelessGatewaysToAdd\": [],\n  \"WirelessGatewaysToRemove\": [],\n  \"Description\": \"\"\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}}/network-analyzer-configurations/:ConfigurationName";

    let payload = json!({
        "TraceContent": json!({
            "WirelessDeviceFrameInfo": "",
            "LogLevel": ""
        }),
        "WirelessDevicesToAdd": (),
        "WirelessDevicesToRemove": (),
        "WirelessGatewaysToAdd": (),
        "WirelessGatewaysToRemove": (),
        "Description": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/network-analyzer-configurations/:ConfigurationName \
  --header 'content-type: application/json' \
  --data '{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}'

echo '{
  "TraceContent": {
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  },
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
}' |  \
  http PATCH {{baseUrl}}/network-analyzer-configurations/:ConfigurationName \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "TraceContent": {\n    "WirelessDeviceFrameInfo": "",\n    "LogLevel": ""\n  },\n  "WirelessDevicesToAdd": [],\n  "WirelessDevicesToRemove": [],\n  "WirelessGatewaysToAdd": [],\n  "WirelessGatewaysToRemove": [],\n  "Description": ""\n}' \
  --output-document \
  - {{baseUrl}}/network-analyzer-configurations/:ConfigurationName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "TraceContent": [
    "WirelessDeviceFrameInfo": "",
    "LogLevel": ""
  ],
  "WirelessDevicesToAdd": [],
  "WirelessDevicesToRemove": [],
  "WirelessGatewaysToAdd": [],
  "WirelessGatewaysToRemove": [],
  "Description": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/network-analyzer-configurations/:ConfigurationName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdatePartnerAccount

{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType

QUERY PARAMS

partnerType

PartnerAccountId

BODY json

{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType");

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    \"AppServerPrivateKey\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType" {:query-params {:partnerType ""}
                                                                                            :content-type :json
                                                                                            :form-params {:Sidewalk {:AppServerPrivateKey ""}}})

require "http/client"

url = "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"),
    Content = new StringContent("{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\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/:PartnerAccountId?partnerType=#partnerType");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"

	payload := strings.NewReader("{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/partner-accounts/:PartnerAccountId?partnerType= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\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    \"AppServerPrivateKey\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .header("content-type", "application/json")
  .body("{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Sidewalk: {
    AppServerPrivateKey: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType',
  params: {partnerType: ''},
  headers: {'content-type': 'application/json'},
  data: {Sidewalk: {AppServerPrivateKey: ''}}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Sidewalk":{"AppServerPrivateKey":""}}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Sidewalk": {\n    "AppServerPrivateKey": ""\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    \"AppServerPrivateKey\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/partner-accounts/:PartnerAccountId?partnerType=',
  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: {AppServerPrivateKey: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType',
  qs: {partnerType: ''},
  headers: {'content-type': 'application/json'},
  body: {Sidewalk: {AppServerPrivateKey: ''}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');

req.query({
  partnerType: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Sidewalk: {
    AppServerPrivateKey: ''
  }
});

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}}/partner-accounts/:PartnerAccountId#partnerType',
  params: {partnerType: ''},
  headers: {'content-type': 'application/json'},
  data: {Sidewalk: {AppServerPrivateKey: ''}}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Sidewalk":{"AppServerPrivateKey":""}}'
};

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": @{ @"AppServerPrivateKey": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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/:PartnerAccountId?partnerType=#partnerType" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Sidewalk' => [
        'AppServerPrivateKey' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType', [
  'body' => '{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'partnerType' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Sidewalk' => [
    'AppServerPrivateKey' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Sidewalk' => [
    'AppServerPrivateKey' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'partnerType' => ''
]));

$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/:PartnerAccountId?partnerType=#partnerType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/partner-accounts/:PartnerAccountId?partnerType=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType"

querystring = {"partnerType":""}

payload = { "Sidewalk": { "AppServerPrivateKey": "" } }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType"

queryString <- list(partnerType = "")

payload <- "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\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.patch('/baseUrl/partner-accounts/:PartnerAccountId') do |req|
  req.params['partnerType'] = ''
  req.body = "{\n  \"Sidewalk\": {\n    \"AppServerPrivateKey\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/partner-accounts/:PartnerAccountId#partnerType";

    let querystring = [
        ("partnerType", ""),
    ];

    let payload = json!({"Sidewalk": json!({"AppServerPrivateKey": ""})});

    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("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' \
  --header 'content-type: application/json' \
  --data '{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}'

echo '{
  "Sidewalk": {
    "AppServerPrivateKey": ""
  }
}' |  \
  http PATCH '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType' \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Sidewalk": {\n    "AppServerPrivateKey": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Sidewalk": ["AppServerPrivateKey": ""]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/partner-accounts/:PartnerAccountId?partnerType=#partnerType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdatePosition

{{baseUrl}}/positions/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

BODY json

{
  "Position": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType");

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  \"Position\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/positions/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}
                                                                                        :content-type :json
                                                                                        :form-params {:Position []}})

require "http/client"

url = "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Position\": []\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"),
    Content = new StringContent("{\n  \"Position\": []\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}}/positions/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Position\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"

	payload := strings.NewReader("{\n  \"Position\": []\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/positions/:ResourceIdentifier?resourceType= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "Position": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Position\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Position\": []\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  \"Position\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .header("content-type", "application/json")
  .body("{\n  \"Position\": []\n}")
  .asString();

const data = JSON.stringify({
  Position: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {Position: []}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Position":[]}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Position": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Position\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/positions/:ResourceIdentifier?resourceType=',
  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({Position: []}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/positions/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  body: {Position: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/positions/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Position: []
});

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}}/positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {Position: []}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Position":[]}'
};

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 = @{ @"Position": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/positions/:ResourceIdentifier?resourceType=#resourceType" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Position\": []\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Position' => [
        
    ]
  ]),
  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('PATCH', '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType', [
  'body' => '{
  "Position": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/positions/:ResourceIdentifier#resourceType');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'resourceType' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Position' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Position' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/positions/:ResourceIdentifier#resourceType');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$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}}/positions/:ResourceIdentifier?resourceType=#resourceType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Position": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Position": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Position\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/positions/:ResourceIdentifier?resourceType=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/positions/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

payload = { "Position": [] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/positions/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

payload <- "{\n  \"Position\": []\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Position\": []\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.patch('/baseUrl/positions/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
  req.body = "{\n  \"Position\": []\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}}/positions/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let payload = json!({"Position": ()});

    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("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType' \
  --header 'content-type: application/json' \
  --data '{
  "Position": []
}'

echo '{
  "Position": []
}' |  \
  http PATCH '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType' \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Position": []\n}' \
  --output-document \
  - '{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Position": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/positions/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateResourceEventConfiguration

{{baseUrl}}/event-configurations/:Identifier#identifierType

QUERY PARAMS

identifierType

Identifier

BODY json

{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType");

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  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/event-configurations/:Identifier#identifierType" {:query-params {:identifierType ""}
                                                                                             :content-type :json
                                                                                             :form-params {:DeviceRegistrationState {:Sidewalk ""
                                                                                                                                     :WirelessDeviceIdEventTopic ""}
                                                                                                           :Proximity {:Sidewalk ""
                                                                                                                       :WirelessDeviceIdEventTopic ""}
                                                                                                           :Join {:LoRaWAN ""
                                                                                                                  :WirelessDeviceIdEventTopic ""}
                                                                                                           :ConnectionStatus {:LoRaWAN ""
                                                                                                                              :WirelessGatewayIdEventTopic ""}
                                                                                                           :MessageDeliveryStatus {:Sidewalk {:AmazonIdEventTopic ""}
                                                                                                                                   :WirelessDeviceIdEventTopic ""}}})

require "http/client"

url = "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"),
    Content = new StringContent("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\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}}/event-configurations/:Identifier?identifierType=#identifierType");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"

	payload := strings.NewReader("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/event-configurations/:Identifier?identifierType= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 460

{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\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  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  DeviceRegistrationState: {
    Sidewalk: '',
    WirelessDeviceIdEventTopic: ''
  },
  Proximity: {
    Sidewalk: '',
    WirelessDeviceIdEventTopic: ''
  },
  Join: {
    LoRaWAN: '',
    WirelessDeviceIdEventTopic: ''
  },
  ConnectionStatus: {
    LoRaWAN: '',
    WirelessGatewayIdEventTopic: ''
  },
  MessageDeliveryStatus: {
    Sidewalk: {
      AmazonIdEventTopic: ''
    },
    WirelessDeviceIdEventTopic: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/event-configurations/:Identifier#identifierType',
  params: {identifierType: ''},
  headers: {'content-type': 'application/json'},
  data: {
    DeviceRegistrationState: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
    Proximity: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
    Join: {LoRaWAN: '', WirelessDeviceIdEventTopic: ''},
    ConnectionStatus: {LoRaWAN: '', WirelessGatewayIdEventTopic: ''},
    MessageDeliveryStatus: {Sidewalk: {AmazonIdEventTopic: ''}, WirelessDeviceIdEventTopic: ''}
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceRegistrationState":{"Sidewalk":"","WirelessDeviceIdEventTopic":""},"Proximity":{"Sidewalk":"","WirelessDeviceIdEventTopic":""},"Join":{"LoRaWAN":"","WirelessDeviceIdEventTopic":""},"ConnectionStatus":{"LoRaWAN":"","WirelessGatewayIdEventTopic":""},"MessageDeliveryStatus":{"Sidewalk":{"AmazonIdEventTopic":""},"WirelessDeviceIdEventTopic":""}}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceRegistrationState": {\n    "Sidewalk": "",\n    "WirelessDeviceIdEventTopic": ""\n  },\n  "Proximity": {\n    "Sidewalk": "",\n    "WirelessDeviceIdEventTopic": ""\n  },\n  "Join": {\n    "LoRaWAN": "",\n    "WirelessDeviceIdEventTopic": ""\n  },\n  "ConnectionStatus": {\n    "LoRaWAN": "",\n    "WirelessGatewayIdEventTopic": ""\n  },\n  "MessageDeliveryStatus": {\n    "Sidewalk": {\n      "AmazonIdEventTopic": ""\n    },\n    "WirelessDeviceIdEventTopic": ""\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  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/event-configurations/:Identifier?identifierType=',
  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({
  DeviceRegistrationState: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
  Proximity: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
  Join: {LoRaWAN: '', WirelessDeviceIdEventTopic: ''},
  ConnectionStatus: {LoRaWAN: '', WirelessGatewayIdEventTopic: ''},
  MessageDeliveryStatus: {Sidewalk: {AmazonIdEventTopic: ''}, WirelessDeviceIdEventTopic: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/event-configurations/:Identifier#identifierType',
  qs: {identifierType: ''},
  headers: {'content-type': 'application/json'},
  body: {
    DeviceRegistrationState: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
    Proximity: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
    Join: {LoRaWAN: '', WirelessDeviceIdEventTopic: ''},
    ConnectionStatus: {LoRaWAN: '', WirelessGatewayIdEventTopic: ''},
    MessageDeliveryStatus: {Sidewalk: {AmazonIdEventTopic: ''}, WirelessDeviceIdEventTopic: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/event-configurations/:Identifier#identifierType');

req.query({
  identifierType: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DeviceRegistrationState: {
    Sidewalk: '',
    WirelessDeviceIdEventTopic: ''
  },
  Proximity: {
    Sidewalk: '',
    WirelessDeviceIdEventTopic: ''
  },
  Join: {
    LoRaWAN: '',
    WirelessDeviceIdEventTopic: ''
  },
  ConnectionStatus: {
    LoRaWAN: '',
    WirelessGatewayIdEventTopic: ''
  },
  MessageDeliveryStatus: {
    Sidewalk: {
      AmazonIdEventTopic: ''
    },
    WirelessDeviceIdEventTopic: ''
  }
});

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}}/event-configurations/:Identifier#identifierType',
  params: {identifierType: ''},
  headers: {'content-type': 'application/json'},
  data: {
    DeviceRegistrationState: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
    Proximity: {Sidewalk: '', WirelessDeviceIdEventTopic: ''},
    Join: {LoRaWAN: '', WirelessDeviceIdEventTopic: ''},
    ConnectionStatus: {LoRaWAN: '', WirelessGatewayIdEventTopic: ''},
    MessageDeliveryStatus: {Sidewalk: {AmazonIdEventTopic: ''}, WirelessDeviceIdEventTopic: ''}
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceRegistrationState":{"Sidewalk":"","WirelessDeviceIdEventTopic":""},"Proximity":{"Sidewalk":"","WirelessDeviceIdEventTopic":""},"Join":{"LoRaWAN":"","WirelessDeviceIdEventTopic":""},"ConnectionStatus":{"LoRaWAN":"","WirelessGatewayIdEventTopic":""},"MessageDeliveryStatus":{"Sidewalk":{"AmazonIdEventTopic":""},"WirelessDeviceIdEventTopic":""}}'
};

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 = @{ @"DeviceRegistrationState": @{ @"Sidewalk": @"", @"WirelessDeviceIdEventTopic": @"" },
                              @"Proximity": @{ @"Sidewalk": @"", @"WirelessDeviceIdEventTopic": @"" },
                              @"Join": @{ @"LoRaWAN": @"", @"WirelessDeviceIdEventTopic": @"" },
                              @"ConnectionStatus": @{ @"LoRaWAN": @"", @"WirelessGatewayIdEventTopic": @"" },
                              @"MessageDeliveryStatus": @{ @"Sidewalk": @{ @"AmazonIdEventTopic": @"" }, @"WirelessDeviceIdEventTopic": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/event-configurations/:Identifier?identifierType=#identifierType" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceRegistrationState' => [
        'Sidewalk' => '',
        'WirelessDeviceIdEventTopic' => ''
    ],
    'Proximity' => [
        'Sidewalk' => '',
        'WirelessDeviceIdEventTopic' => ''
    ],
    'Join' => [
        'LoRaWAN' => '',
        'WirelessDeviceIdEventTopic' => ''
    ],
    'ConnectionStatus' => [
        'LoRaWAN' => '',
        'WirelessGatewayIdEventTopic' => ''
    ],
    'MessageDeliveryStatus' => [
        'Sidewalk' => [
                'AmazonIdEventTopic' => ''
        ],
        'WirelessDeviceIdEventTopic' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType', [
  'body' => '{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/event-configurations/:Identifier#identifierType');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'identifierType' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceRegistrationState' => [
    'Sidewalk' => '',
    'WirelessDeviceIdEventTopic' => ''
  ],
  'Proximity' => [
    'Sidewalk' => '',
    'WirelessDeviceIdEventTopic' => ''
  ],
  'Join' => [
    'LoRaWAN' => '',
    'WirelessDeviceIdEventTopic' => ''
  ],
  'ConnectionStatus' => [
    'LoRaWAN' => '',
    'WirelessGatewayIdEventTopic' => ''
  ],
  'MessageDeliveryStatus' => [
    'Sidewalk' => [
        'AmazonIdEventTopic' => ''
    ],
    'WirelessDeviceIdEventTopic' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DeviceRegistrationState' => [
    'Sidewalk' => '',
    'WirelessDeviceIdEventTopic' => ''
  ],
  'Proximity' => [
    'Sidewalk' => '',
    'WirelessDeviceIdEventTopic' => ''
  ],
  'Join' => [
    'LoRaWAN' => '',
    'WirelessDeviceIdEventTopic' => ''
  ],
  'ConnectionStatus' => [
    'LoRaWAN' => '',
    'WirelessGatewayIdEventTopic' => ''
  ],
  'MessageDeliveryStatus' => [
    'Sidewalk' => [
        'AmazonIdEventTopic' => ''
    ],
    'WirelessDeviceIdEventTopic' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/event-configurations/:Identifier#identifierType');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'identifierType' => ''
]));

$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}}/event-configurations/:Identifier?identifierType=#identifierType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/event-configurations/:Identifier?identifierType=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/event-configurations/:Identifier#identifierType"

querystring = {"identifierType":""}

payload = {
    "DeviceRegistrationState": {
        "Sidewalk": "",
        "WirelessDeviceIdEventTopic": ""
    },
    "Proximity": {
        "Sidewalk": "",
        "WirelessDeviceIdEventTopic": ""
    },
    "Join": {
        "LoRaWAN": "",
        "WirelessDeviceIdEventTopic": ""
    },
    "ConnectionStatus": {
        "LoRaWAN": "",
        "WirelessGatewayIdEventTopic": ""
    },
    "MessageDeliveryStatus": {
        "Sidewalk": { "AmazonIdEventTopic": "" },
        "WirelessDeviceIdEventTopic": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-configurations/:Identifier#identifierType"

queryString <- list(identifierType = "")

payload <- "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\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.patch('/baseUrl/event-configurations/:Identifier') do |req|
  req.params['identifierType'] = ''
  req.body = "{\n  \"DeviceRegistrationState\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Proximity\": {\n    \"Sidewalk\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"Join\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessDeviceIdEventTopic\": \"\"\n  },\n  \"ConnectionStatus\": {\n    \"LoRaWAN\": \"\",\n    \"WirelessGatewayIdEventTopic\": \"\"\n  },\n  \"MessageDeliveryStatus\": {\n    \"Sidewalk\": {\n      \"AmazonIdEventTopic\": \"\"\n    },\n    \"WirelessDeviceIdEventTopic\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/event-configurations/:Identifier#identifierType";

    let querystring = [
        ("identifierType", ""),
    ];

    let payload = json!({
        "DeviceRegistrationState": json!({
            "Sidewalk": "",
            "WirelessDeviceIdEventTopic": ""
        }),
        "Proximity": json!({
            "Sidewalk": "",
            "WirelessDeviceIdEventTopic": ""
        }),
        "Join": json!({
            "LoRaWAN": "",
            "WirelessDeviceIdEventTopic": ""
        }),
        "ConnectionStatus": json!({
            "LoRaWAN": "",
            "WirelessGatewayIdEventTopic": ""
        }),
        "MessageDeliveryStatus": json!({
            "Sidewalk": json!({"AmazonIdEventTopic": ""}),
            "WirelessDeviceIdEventTopic": ""
        })
    });

    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("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType' \
  --header 'content-type: application/json' \
  --data '{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}'

echo '{
  "DeviceRegistrationState": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Proximity": {
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "Join": {
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  },
  "ConnectionStatus": {
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  },
  "MessageDeliveryStatus": {
    "Sidewalk": {
      "AmazonIdEventTopic": ""
    },
    "WirelessDeviceIdEventTopic": ""
  }
}' |  \
  http PATCH '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType' \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceRegistrationState": {\n    "Sidewalk": "",\n    "WirelessDeviceIdEventTopic": ""\n  },\n  "Proximity": {\n    "Sidewalk": "",\n    "WirelessDeviceIdEventTopic": ""\n  },\n  "Join": {\n    "LoRaWAN": "",\n    "WirelessDeviceIdEventTopic": ""\n  },\n  "ConnectionStatus": {\n    "LoRaWAN": "",\n    "WirelessGatewayIdEventTopic": ""\n  },\n  "MessageDeliveryStatus": {\n    "Sidewalk": {\n      "AmazonIdEventTopic": ""\n    },\n    "WirelessDeviceIdEventTopic": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DeviceRegistrationState": [
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  ],
  "Proximity": [
    "Sidewalk": "",
    "WirelessDeviceIdEventTopic": ""
  ],
  "Join": [
    "LoRaWAN": "",
    "WirelessDeviceIdEventTopic": ""
  ],
  "ConnectionStatus": [
    "LoRaWAN": "",
    "WirelessGatewayIdEventTopic": ""
  ],
  "MessageDeliveryStatus": [
    "Sidewalk": ["AmazonIdEventTopic": ""],
    "WirelessDeviceIdEventTopic": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event-configurations/:Identifier?identifierType=#identifierType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateResourcePosition

{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType

QUERY PARAMS

resourceType

ResourceIdentifier

BODY json

{
  "GeoJsonPayload": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType");

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  \"GeoJsonPayload\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType" {:query-params {:resourceType ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:GeoJsonPayload ""}})

require "http/client"

url = "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GeoJsonPayload\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"),
    Content = new StringContent("{\n  \"GeoJsonPayload\": \"\"\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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GeoJsonPayload\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"

	payload := strings.NewReader("{\n  \"GeoJsonPayload\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/resource-positions/:ResourceIdentifier?resourceType= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "GeoJsonPayload": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GeoJsonPayload\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"GeoJsonPayload\": \"\"\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  \"GeoJsonPayload\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .header("content-type", "application/json")
  .body("{\n  \"GeoJsonPayload\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GeoJsonPayload: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {GeoJsonPayload: ''}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"GeoJsonPayload":""}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GeoJsonPayload": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GeoJsonPayload\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource-positions/:ResourceIdentifier?resourceType=',
  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({GeoJsonPayload: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType',
  qs: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  body: {GeoJsonPayload: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType');

req.query({
  resourceType: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GeoJsonPayload: ''
});

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}}/resource-positions/:ResourceIdentifier#resourceType',
  params: {resourceType: ''},
  headers: {'content-type': 'application/json'},
  data: {GeoJsonPayload: ''}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"GeoJsonPayload":""}'
};

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 = @{ @"GeoJsonPayload": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GeoJsonPayload\": \"\"\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'GeoJsonPayload' => ''
  ]),
  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('PATCH', '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType', [
  'body' => '{
  "GeoJsonPayload": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'resourceType' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GeoJsonPayload' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GeoJsonPayload' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'resourceType' => ''
]));

$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}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "GeoJsonPayload": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "GeoJsonPayload": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GeoJsonPayload\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/resource-positions/:ResourceIdentifier?resourceType=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType"

querystring = {"resourceType":""}

payload = { "GeoJsonPayload": "" }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource-positions/:ResourceIdentifier#resourceType"

queryString <- list(resourceType = "")

payload <- "{\n  \"GeoJsonPayload\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"GeoJsonPayload\": \"\"\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.patch('/baseUrl/resource-positions/:ResourceIdentifier') do |req|
  req.params['resourceType'] = ''
  req.body = "{\n  \"GeoJsonPayload\": \"\"\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}}/resource-positions/:ResourceIdentifier#resourceType";

    let querystring = [
        ("resourceType", ""),
    ];

    let payload = json!({"GeoJsonPayload": ""});

    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("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType' \
  --header 'content-type: application/json' \
  --data '{
  "GeoJsonPayload": ""
}'

echo '{
  "GeoJsonPayload": ""
}' |  \
  http PATCH '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType' \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "GeoJsonPayload": ""\n}' \
  --output-document \
  - '{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["GeoJsonPayload": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource-positions/:ResourceIdentifier?resourceType=#resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateWirelessDevice

{{baseUrl}}/wireless-devices/:Id

QUERY PARAMS

BODY json

{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-devices/:Id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/wireless-devices/:Id" {:content-type :json
                                                                  :form-params {:DestinationName ""
                                                                                :Name ""
                                                                                :Description ""
                                                                                :LoRaWAN {:DeviceProfileId ""
                                                                                          :ServiceProfileId ""
                                                                                          :AbpV1_1 ""
                                                                                          :AbpV1_0_x ""
                                                                                          :FPorts ""}
                                                                                :Positioning ""}})

require "http/client"

url = "{{baseUrl}}/wireless-devices/:Id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
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/:Id"),
    Content = new StringContent("{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\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");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-devices/:Id"

	payload := strings.NewReader("{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/wireless-devices/:Id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 215

{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/wireless-devices/:Id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-devices/:Id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\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  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/wireless-devices/:Id")
  .header("content-type", "application/json")
  .body("{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DestinationName: '',
  Name: '',
  Description: '',
  LoRaWAN: {
    DeviceProfileId: '',
    ServiceProfileId: '',
    AbpV1_1: '',
    AbpV1_0_x: '',
    FPorts: ''
  },
  Positioning: ''
});

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/:Id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless-devices/:Id',
  headers: {'content-type': 'application/json'},
  data: {
    DestinationName: '',
    Name: '',
    Description: '',
    LoRaWAN: {
      DeviceProfileId: '',
      ServiceProfileId: '',
      AbpV1_1: '',
      AbpV1_0_x: '',
      FPorts: ''
    },
    Positioning: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-devices/:Id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"DestinationName":"","Name":"","Description":"","LoRaWAN":{"DeviceProfileId":"","ServiceProfileId":"","AbpV1_1":"","AbpV1_0_x":"","FPorts":""},"Positioning":""}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DestinationName": "",\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "DeviceProfileId": "",\n    "ServiceProfileId": "",\n    "AbpV1_1": "",\n    "AbpV1_0_x": "",\n    "FPorts": ""\n  },\n  "Positioning": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless-devices/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-devices/:Id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  DestinationName: '',
  Name: '',
  Description: '',
  LoRaWAN: {
    DeviceProfileId: '',
    ServiceProfileId: '',
    AbpV1_1: '',
    AbpV1_0_x: '',
    FPorts: ''
  },
  Positioning: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless-devices/:Id',
  headers: {'content-type': 'application/json'},
  body: {
    DestinationName: '',
    Name: '',
    Description: '',
    LoRaWAN: {
      DeviceProfileId: '',
      ServiceProfileId: '',
      AbpV1_1: '',
      AbpV1_0_x: '',
      FPorts: ''
    },
    Positioning: ''
  },
  json: true
};

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/:Id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DestinationName: '',
  Name: '',
  Description: '',
  LoRaWAN: {
    DeviceProfileId: '',
    ServiceProfileId: '',
    AbpV1_1: '',
    AbpV1_0_x: '',
    FPorts: ''
  },
  Positioning: ''
});

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/:Id',
  headers: {'content-type': 'application/json'},
  data: {
    DestinationName: '',
    Name: '',
    Description: '',
    LoRaWAN: {
      DeviceProfileId: '',
      ServiceProfileId: '',
      AbpV1_1: '',
      AbpV1_0_x: '',
      FPorts: ''
    },
    Positioning: ''
  }
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"DestinationName":"","Name":"","Description":"","LoRaWAN":{"DeviceProfileId":"","ServiceProfileId":"","AbpV1_1":"","AbpV1_0_x":"","FPorts":""},"Positioning":""}'
};

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 = @{ @"DestinationName": @"",
                              @"Name": @"",
                              @"Description": @"",
                              @"LoRaWAN": @{ @"DeviceProfileId": @"", @"ServiceProfileId": @"", @"AbpV1_1": @"", @"AbpV1_0_x": @"", @"FPorts": @"" },
                              @"Positioning": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-devices/:Id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'DestinationName' => '',
    'Name' => '',
    'Description' => '',
    'LoRaWAN' => [
        'DeviceProfileId' => '',
        'ServiceProfileId' => '',
        'AbpV1_1' => '',
        'AbpV1_0_x' => '',
        'FPorts' => ''
    ],
    'Positioning' => ''
  ]),
  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('PATCH', '{{baseUrl}}/wireless-devices/:Id', [
  'body' => '{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-devices/:Id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DestinationName' => '',
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'DeviceProfileId' => '',
    'ServiceProfileId' => '',
    'AbpV1_1' => '',
    'AbpV1_0_x' => '',
    'FPorts' => ''
  ],
  'Positioning' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DestinationName' => '',
  'Name' => '',
  'Description' => '',
  'LoRaWAN' => [
    'DeviceProfileId' => '',
    'ServiceProfileId' => '',
    'AbpV1_1' => '',
    'AbpV1_0_x' => '',
    'FPorts' => ''
  ],
  'Positioning' => ''
]));
$request->setRequestUrl('{{baseUrl}}/wireless-devices/:Id');
$request->setRequestMethod('PATCH');
$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' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-devices/:Id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/wireless-devices/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-devices/:Id"

payload = {
    "DestinationName": "",
    "Name": "",
    "Description": "",
    "LoRaWAN": {
        "DeviceProfileId": "",
        "ServiceProfileId": "",
        "AbpV1_1": "",
        "AbpV1_0_x": "",
        "FPorts": ""
    },
    "Positioning": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-devices/:Id"

payload <- "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\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.patch('/baseUrl/wireless-devices/:Id') do |req|
  req.body = "{\n  \"DestinationName\": \"\",\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LoRaWAN\": {\n    \"DeviceProfileId\": \"\",\n    \"ServiceProfileId\": \"\",\n    \"AbpV1_1\": \"\",\n    \"AbpV1_0_x\": \"\",\n    \"FPorts\": \"\"\n  },\n  \"Positioning\": \"\"\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";

    let payload = json!({
        "DestinationName": "",
        "Name": "",
        "Description": "",
        "LoRaWAN": json!({
            "DeviceProfileId": "",
            "ServiceProfileId": "",
            "AbpV1_1": "",
            "AbpV1_0_x": "",
            "FPorts": ""
        }),
        "Positioning": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/wireless-devices/:Id \
  --header 'content-type: application/json' \
  --data '{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}'

echo '{
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": {
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  },
  "Positioning": ""
}' |  \
  http PATCH {{baseUrl}}/wireless-devices/:Id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "DestinationName": "",\n  "Name": "",\n  "Description": "",\n  "LoRaWAN": {\n    "DeviceProfileId": "",\n    "ServiceProfileId": "",\n    "AbpV1_1": "",\n    "AbpV1_0_x": "",\n    "FPorts": ""\n  },\n  "Positioning": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-devices/:Id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DestinationName": "",
  "Name": "",
  "Description": "",
  "LoRaWAN": [
    "DeviceProfileId": "",
    "ServiceProfileId": "",
    "AbpV1_1": "",
    "AbpV1_0_x": "",
    "FPorts": ""
  ],
  "Positioning": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-devices/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateWirelessDeviceImportTask

{{baseUrl}}/wireless_device_import_task/:Id

QUERY PARAMS

BODY json

{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless_device_import_task/:Id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/wireless_device_import_task/:Id" {:content-type :json
                                                                             :form-params {:Sidewalk {:DeviceCreationFile ""}}})

require "http/client"

url = "{{baseUrl}}/wireless_device_import_task/:Id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/wireless_device_import_task/:Id"),
    Content = new StringContent("{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\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_device_import_task/:Id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless_device_import_task/:Id"

	payload := strings.NewReader("{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/wireless_device_import_task/:Id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/wireless_device_import_task/:Id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless_device_import_task/:Id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\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    \"DeviceCreationFile\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless_device_import_task/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/wireless_device_import_task/:Id")
  .header("content-type", "application/json")
  .body("{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Sidewalk: {
    DeviceCreationFile: ''
  }
});

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_device_import_task/:Id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless_device_import_task/:Id',
  headers: {'content-type': 'application/json'},
  data: {Sidewalk: {DeviceCreationFile: ''}}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Sidewalk":{"DeviceCreationFile":""}}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Sidewalk": {\n    "DeviceCreationFile": ""\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    \"DeviceCreationFile\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless_device_import_task/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless_device_import_task/:Id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Sidewalk: {DeviceCreationFile: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless_device_import_task/:Id',
  headers: {'content-type': 'application/json'},
  body: {Sidewalk: {DeviceCreationFile: ''}},
  json: true
};

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_device_import_task/:Id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Sidewalk: {
    DeviceCreationFile: ''
  }
});

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_device_import_task/:Id',
  headers: {'content-type': 'application/json'},
  data: {Sidewalk: {DeviceCreationFile: ''}}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Sidewalk":{"DeviceCreationFile":""}}'
};

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": @{ @"DeviceCreationFile": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless_device_import_task/:Id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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_device_import_task/:Id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Sidewalk' => [
        'DeviceCreationFile' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/wireless_device_import_task/:Id', [
  'body' => '{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless_device_import_task/:Id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Sidewalk' => [
    'DeviceCreationFile' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Sidewalk' => [
    'DeviceCreationFile' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/wireless_device_import_task/:Id');
$request->setRequestMethod('PATCH');
$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_device_import_task/:Id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless_device_import_task/:Id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/wireless_device_import_task/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless_device_import_task/:Id"

payload = { "Sidewalk": { "DeviceCreationFile": "" } }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless_device_import_task/:Id"

payload <- "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\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.patch('/baseUrl/wireless_device_import_task/:Id') do |req|
  req.body = "{\n  \"Sidewalk\": {\n    \"DeviceCreationFile\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wireless_device_import_task/:Id";

    let payload = json!({"Sidewalk": json!({"DeviceCreationFile": ""})});

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/wireless_device_import_task/:Id \
  --header 'content-type: application/json' \
  --data '{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}'

echo '{
  "Sidewalk": {
    "DeviceCreationFile": ""
  }
}' |  \
  http PATCH {{baseUrl}}/wireless_device_import_task/:Id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Sidewalk": {\n    "DeviceCreationFile": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/wireless_device_import_task/:Id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Sidewalk": ["DeviceCreationFile": ""]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless_device_import_task/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()

PATCH UpdateWirelessGateway

{{baseUrl}}/wireless-gateways/:Id

QUERY PARAMS

BODY json

{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wireless-gateways/:Id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/wireless-gateways/:Id" {:content-type :json
                                                                   :form-params {:Name ""
                                                                                 :Description ""
                                                                                 :JoinEuiFilters []
                                                                                 :NetIdFilters []
                                                                                 :MaxEirp ""}})

require "http/client"

url = "{{baseUrl}}/wireless-gateways/:Id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/wireless-gateways/:Id"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\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");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/wireless-gateways/:Id"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/wireless-gateways/:Id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 100

{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/wireless-gateways/:Id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wireless-gateways/:Id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\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  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/wireless-gateways/:Id")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  JoinEuiFilters: [],
  NetIdFilters: [],
  MaxEirp: ''
});

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-gateways/:Id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless-gateways/:Id',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', JoinEuiFilters: [], NetIdFilters: [], MaxEirp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/wireless-gateways/:Id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","JoinEuiFilters":[],"NetIdFilters":[],"MaxEirp":""}'
};

try {
  const response = await 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: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "JoinEuiFilters": [],\n  "NetIdFilters": [],\n  "MaxEirp": ""\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  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/wireless-gateways/:Id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wireless-gateways/:Id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', Description: '', JoinEuiFilters: [], NetIdFilters: [], MaxEirp: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/wireless-gateways/:Id',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', JoinEuiFilters: [], NetIdFilters: [], MaxEirp: ''},
  json: true
};

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-gateways/:Id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Description: '',
  JoinEuiFilters: [],
  NetIdFilters: [],
  MaxEirp: ''
});

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-gateways/:Id',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', JoinEuiFilters: [], NetIdFilters: [], MaxEirp: ''}
};

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: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","JoinEuiFilters":[],"NetIdFilters":[],"MaxEirp":""}'
};

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": @"",
                              @"JoinEuiFilters": @[  ],
                              @"NetIdFilters": @[  ],
                              @"MaxEirp": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wireless-gateways/:Id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'JoinEuiFilters' => [
        
    ],
    'NetIdFilters' => [
        
    ],
    'MaxEirp' => ''
  ]),
  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('PATCH', '{{baseUrl}}/wireless-gateways/:Id', [
  'body' => '{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/wireless-gateways/:Id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'JoinEuiFilters' => [
    
  ],
  'NetIdFilters' => [
    
  ],
  'MaxEirp' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Description' => '',
  'JoinEuiFilters' => [
    
  ],
  'NetIdFilters' => [
    
  ],
  'MaxEirp' => ''
]));
$request->setRequestUrl('{{baseUrl}}/wireless-gateways/:Id');
$request->setRequestMethod('PATCH');
$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' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wireless-gateways/:Id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/wireless-gateways/:Id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/wireless-gateways/:Id"

payload = {
    "Name": "",
    "Description": "",
    "JoinEuiFilters": [],
    "NetIdFilters": [],
    "MaxEirp": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/wireless-gateways/:Id"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

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::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\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.patch('/baseUrl/wireless-gateways/:Id') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"JoinEuiFilters\": [],\n  \"NetIdFilters\": [],\n  \"MaxEirp\": \"\"\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";

    let payload = json!({
        "Name": "",
        "Description": "",
        "JoinEuiFilters": (),
        "NetIdFilters": (),
        "MaxEirp": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/wireless-gateways/:Id \
  --header 'content-type: application/json' \
  --data '{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}'

echo '{
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
}' |  \
  http PATCH {{baseUrl}}/wireless-gateways/:Id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "JoinEuiFilters": [],\n  "NetIdFilters": [],\n  "MaxEirp": ""\n}' \
  --output-document \
  - {{baseUrl}}/wireless-gateways/:Id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "JoinEuiFilters": [],
  "NetIdFilters": [],
  "MaxEirp": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wireless-gateways/:Id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()