CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/customers")

require "http/client"

url = "{{baseUrl}}/v1alpha1/customers"

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

var client = new RestClient("{{baseUrl}}/v1alpha1/customers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/customers"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const url = '{{baseUrl}}/v1alpha1/customers';
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}}/v1alpha1/customers"]
                                                       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}}/v1alpha1/customers" in

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

 "{{baseUrl}}/v1alpha1/customers",
  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}}/v1alpha1/customers');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/customers")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/customers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/customers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/customers")

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/v1alpha1/customers') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/customers

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/customers:provisionDeployment");

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  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/customers:provisionDeployment" {:content-type :json
                                                                                   :form-params {:newDeploymentDisplayName ""
                                                                                                 :newOrganizationDisplayName ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/customers:provisionDeployment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\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}}/v1alpha1/customers:provisionDeployment"),
    Content = new StringContent("{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\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}}/v1alpha1/customers:provisionDeployment");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/customers:provisionDeployment"

	payload := strings.NewReader("{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\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/v1alpha1/customers:provisionDeployment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "newDeploymentDisplayName": "",
  "newOrganizationDisplayName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/customers:provisionDeployment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/customers:provisionDeployment"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\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  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/customers:provisionDeployment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/customers:provisionDeployment")
  .header("content-type", "application/json")
  .body("{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  newDeploymentDisplayName: '',
  newOrganizationDisplayName: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/customers:provisionDeployment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/customers:provisionDeployment',
  headers: {'content-type': 'application/json'},
  data: {newDeploymentDisplayName: '', newOrganizationDisplayName: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/customers:provisionDeployment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newDeploymentDisplayName":"","newOrganizationDisplayName":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/customers:provisionDeployment',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "newDeploymentDisplayName": "",\n  "newOrganizationDisplayName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/customers:provisionDeployment")
  .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/v1alpha1/customers:provisionDeployment',
  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({newDeploymentDisplayName: '', newOrganizationDisplayName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/customers:provisionDeployment',
  headers: {'content-type': 'application/json'},
  body: {newDeploymentDisplayName: '', newOrganizationDisplayName: ''},
  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}}/v1alpha1/customers:provisionDeployment');

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

req.type('json');
req.send({
  newDeploymentDisplayName: '',
  newOrganizationDisplayName: ''
});

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}}/v1alpha1/customers:provisionDeployment',
  headers: {'content-type': 'application/json'},
  data: {newDeploymentDisplayName: '', newOrganizationDisplayName: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/customers:provisionDeployment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newDeploymentDisplayName":"","newOrganizationDisplayName":""}'
};

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 = @{ @"newDeploymentDisplayName": @"",
                              @"newOrganizationDisplayName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/customers:provisionDeployment"]
                                                       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}}/v1alpha1/customers:provisionDeployment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/customers:provisionDeployment",
  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([
    'newDeploymentDisplayName' => '',
    'newOrganizationDisplayName' => ''
  ]),
  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}}/v1alpha1/customers:provisionDeployment', [
  'body' => '{
  "newDeploymentDisplayName": "",
  "newOrganizationDisplayName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/customers:provisionDeployment');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'newDeploymentDisplayName' => '',
  'newOrganizationDisplayName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/customers:provisionDeployment');
$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}}/v1alpha1/customers:provisionDeployment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newDeploymentDisplayName": "",
  "newOrganizationDisplayName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/customers:provisionDeployment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newDeploymentDisplayName": "",
  "newOrganizationDisplayName": ""
}'

import http.client

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

payload = "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/customers:provisionDeployment", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/customers:provisionDeployment"

payload = {
    "newDeploymentDisplayName": "",
    "newOrganizationDisplayName": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/customers:provisionDeployment"

payload <- "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\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}}/v1alpha1/customers:provisionDeployment")

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  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\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/v1alpha1/customers:provisionDeployment') do |req|
  req.body = "{\n  \"newDeploymentDisplayName\": \"\",\n  \"newOrganizationDisplayName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "newDeploymentDisplayName": "",
        "newOrganizationDisplayName": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "newDeploymentDisplayName": "",
  "newOrganizationDisplayName": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/customers:provisionDeployment \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "newDeploymentDisplayName": "",\n  "newOrganizationDisplayName": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/customers:provisionDeployment

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/installer:generateSecret");

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, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/installer:generateSecret" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1alpha1/installer:generateSecret"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/v1alpha1/installer:generateSecret"),
    Content = new StringContent("{}")
    {
        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}}/v1alpha1/installer:generateSecret");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/installer:generateSecret"

	payload := strings.NewReader("{}")

	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/v1alpha1/installer:generateSecret HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/installer:generateSecret")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/installer:generateSecret"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/installer:generateSecret")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/installer:generateSecret")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/installer:generateSecret');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/installer:generateSecret',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1alpha1/installer:generateSecret';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/installer:generateSecret',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/installer:generateSecret")
  .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/v1alpha1/installer:generateSecret',
  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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/installer:generateSecret',
  headers: {'content-type': 'application/json'},
  body: {},
  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}}/v1alpha1/installer:generateSecret');

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

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

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

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/installer:generateSecret',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/v1alpha1/installer:generateSecret';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

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

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

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

 "{{baseUrl}}/v1alpha1/installer:generateSecret",
  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([
    
  ]),
  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}}/v1alpha1/installer:generateSecret', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/installer:generateSecret');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/installer:generateSecret');
$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}}/v1alpha1/installer:generateSecret' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/installer:generateSecret' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/v1alpha1/installer:generateSecret", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/installer:generateSecret"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/installer:generateSecret"

payload <- "{}"

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}}/v1alpha1/installer:generateSecret")

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

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/v1alpha1/installer:generateSecret') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http POST {{baseUrl}}/v1alpha1/installer:generateSecret \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/installer:generateSecret

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/installer:validate");

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  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/installer:validate" {:content-type :json
                                                                        :form-params {:encodedSecret ""
                                                                                      :installerId ""
                                                                                      :secret ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/installer:validate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\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}}/v1alpha1/installer:validate"),
    Content = new StringContent("{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\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}}/v1alpha1/installer:validate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/installer:validate"

	payload := strings.NewReader("{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\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/v1alpha1/installer:validate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 62

{
  "encodedSecret": "",
  "installerId": "",
  "secret": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/installer:validate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/installer:validate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\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  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/installer:validate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/installer:validate")
  .header("content-type", "application/json")
  .body("{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  encodedSecret: '',
  installerId: '',
  secret: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/installer:validate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/installer:validate',
  headers: {'content-type': 'application/json'},
  data: {encodedSecret: '', installerId: '', secret: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/installer:validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encodedSecret":"","installerId":"","secret":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/installer:validate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "encodedSecret": "",\n  "installerId": "",\n  "secret": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/installer:validate")
  .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/v1alpha1/installer:validate',
  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({encodedSecret: '', installerId: '', secret: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/installer:validate',
  headers: {'content-type': 'application/json'},
  body: {encodedSecret: '', installerId: '', secret: ''},
  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}}/v1alpha1/installer:validate');

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

req.type('json');
req.send({
  encodedSecret: '',
  installerId: '',
  secret: ''
});

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}}/v1alpha1/installer:validate',
  headers: {'content-type': 'application/json'},
  data: {encodedSecret: '', installerId: '', secret: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/installer:validate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encodedSecret":"","installerId":"","secret":""}'
};

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 = @{ @"encodedSecret": @"",
                              @"installerId": @"",
                              @"secret": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/installer:validate"]
                                                       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}}/v1alpha1/installer:validate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/installer:validate",
  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([
    'encodedSecret' => '',
    'installerId' => '',
    'secret' => ''
  ]),
  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}}/v1alpha1/installer:validate', [
  'body' => '{
  "encodedSecret": "",
  "installerId": "",
  "secret": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'encodedSecret' => '',
  'installerId' => '',
  'secret' => ''
]));

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

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

append(json_encode([
  'encodedSecret' => '',
  'installerId' => '',
  'secret' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/installer:validate');
$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}}/v1alpha1/installer:validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encodedSecret": "",
  "installerId": "",
  "secret": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/installer:validate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encodedSecret": "",
  "installerId": "",
  "secret": ""
}'

import http.client

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

payload = "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/installer:validate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/installer:validate"

payload = {
    "encodedSecret": "",
    "installerId": "",
    "secret": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/installer:validate"

payload <- "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\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}}/v1alpha1/installer:validate")

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  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\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/v1alpha1/installer:validate') do |req|
  req.body = "{\n  \"encodedSecret\": \"\",\n  \"installerId\": \"\",\n  \"secret\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "encodedSecret": "",
        "installerId": "",
        "secret": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "encodedSecret": "",
  "installerId": "",
  "secret": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/installer:validate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "encodedSecret": "",\n  "installerId": "",\n  "secret": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/installer:validate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "encodedSecret": "",
  "installerId": "",
  "secret": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name:signDevice");

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  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:signDevice" {:content-type :json
                                                                      :form-params {:device {:activeConfig {:airInterface {:radioTechnology ""
                                                                                                                           :supportedSpec ""}
                                                                                                            :callSign ""
                                                                                                            :category ""
                                                                                                            :installationParams {:antennaAzimuth 0
                                                                                                                                 :antennaBeamwidth 0
                                                                                                                                 :antennaDowntilt 0
                                                                                                                                 :antennaGain 0
                                                                                                                                 :antennaGainNewField ""
                                                                                                                                 :antennaModel ""
                                                                                                                                 :cpeCbsdIndication false
                                                                                                                                 :eirpCapability 0
                                                                                                                                 :eirpCapabilityNewField ""
                                                                                                                                 :height ""
                                                                                                                                 :heightType ""
                                                                                                                                 :horizontalAccuracy ""
                                                                                                                                 :indoorDeployment false
                                                                                                                                 :latitude ""
                                                                                                                                 :longitude ""
                                                                                                                                 :verticalAccuracy ""}
                                                                                                            :isSigned false
                                                                                                            :measurementCapabilities []
                                                                                                            :model {:firmwareVersion ""
                                                                                                                    :hardwareVersion ""
                                                                                                                    :name ""
                                                                                                                    :softwareVersion ""
                                                                                                                    :vendor ""}
                                                                                                            :state ""
                                                                                                            :updateTime ""
                                                                                                            :userId ""}
                                                                                             :currentChannels [{:frequencyRange {:highFrequencyMhz ""
                                                                                                                                 :lowFrequencyMhz ""}
                                                                                                                :score ""}]
                                                                                             :deviceMetadata {:antennaModel ""
                                                                                                              :commonChannelGroup ""
                                                                                                              :interferenceCoordinationGroup ""
                                                                                                              :nrqzValidated false
                                                                                                              :nrqzValidation {:caseId ""
                                                                                                                               :cpiId ""
                                                                                                                               :latitude ""
                                                                                                                               :longitude ""
                                                                                                                               :state ""}}
                                                                                             :displayName ""
                                                                                             :fccId ""
                                                                                             :grantRangeAllowlists [{}]
                                                                                             :grants [{:channelType ""
                                                                                                       :expireTime ""
                                                                                                       :frequencyRange {}
                                                                                                       :grantId ""
                                                                                                       :lastHeartbeatTransmitExpireTime ""
                                                                                                       :maxEirp ""
                                                                                                       :moveList [{:dpaId ""
                                                                                                                   :frequencyRange {}}]
                                                                                                       :state ""
                                                                                                       :suspensionReason []}]
                                                                                             :name ""
                                                                                             :preloadedConfig {}
                                                                                             :serialNumber ""
                                                                                             :state ""}}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:signDevice"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\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}}/v1alpha1/:name:signDevice"),
    Content = new StringContent("{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\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}}/v1alpha1/:name:signDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:signDevice"

	payload := strings.NewReader("{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\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/v1alpha1/:name:signDevice HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2020

{
  "device": {
    "activeConfig": {
      "airInterface": {
        "radioTechnology": "",
        "supportedSpec": ""
      },
      "callSign": "",
      "category": "",
      "installationParams": {
        "antennaAzimuth": 0,
        "antennaBeamwidth": 0,
        "antennaDowntilt": 0,
        "antennaGain": 0,
        "antennaGainNewField": "",
        "antennaModel": "",
        "cpeCbsdIndication": false,
        "eirpCapability": 0,
        "eirpCapabilityNewField": "",
        "height": "",
        "heightType": "",
        "horizontalAccuracy": "",
        "indoorDeployment": false,
        "latitude": "",
        "longitude": "",
        "verticalAccuracy": ""
      },
      "isSigned": false,
      "measurementCapabilities": [],
      "model": {
        "firmwareVersion": "",
        "hardwareVersion": "",
        "name": "",
        "softwareVersion": "",
        "vendor": ""
      },
      "state": "",
      "updateTime": "",
      "userId": ""
    },
    "currentChannels": [
      {
        "frequencyRange": {
          "highFrequencyMhz": "",
          "lowFrequencyMhz": ""
        },
        "score": ""
      }
    ],
    "deviceMetadata": {
      "antennaModel": "",
      "commonChannelGroup": "",
      "interferenceCoordinationGroup": "",
      "nrqzValidated": false,
      "nrqzValidation": {
        "caseId": "",
        "cpiId": "",
        "latitude": "",
        "longitude": "",
        "state": ""
      }
    },
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [
      {}
    ],
    "grants": [
      {
        "channelType": "",
        "expireTime": "",
        "frequencyRange": {},
        "grantId": "",
        "lastHeartbeatTransmitExpireTime": "",
        "maxEirp": "",
        "moveList": [
          {
            "dpaId": "",
            "frequencyRange": {}
          }
        ],
        "state": "",
        "suspensionReason": []
      }
    ],
    "name": "",
    "preloadedConfig": {},
    "serialNumber": "",
    "state": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:name:signDevice")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:signDevice"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\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  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:signDevice")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:signDevice")
  .header("content-type", "application/json")
  .body("{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  device: {
    activeConfig: {
      airInterface: {
        radioTechnology: '',
        supportedSpec: ''
      },
      callSign: '',
      category: '',
      installationParams: {
        antennaAzimuth: 0,
        antennaBeamwidth: 0,
        antennaDowntilt: 0,
        antennaGain: 0,
        antennaGainNewField: '',
        antennaModel: '',
        cpeCbsdIndication: false,
        eirpCapability: 0,
        eirpCapabilityNewField: '',
        height: '',
        heightType: '',
        horizontalAccuracy: '',
        indoorDeployment: false,
        latitude: '',
        longitude: '',
        verticalAccuracy: ''
      },
      isSigned: false,
      measurementCapabilities: [],
      model: {
        firmwareVersion: '',
        hardwareVersion: '',
        name: '',
        softwareVersion: '',
        vendor: ''
      },
      state: '',
      updateTime: '',
      userId: ''
    },
    currentChannels: [
      {
        frequencyRange: {
          highFrequencyMhz: '',
          lowFrequencyMhz: ''
        },
        score: ''
      }
    ],
    deviceMetadata: {
      antennaModel: '',
      commonChannelGroup: '',
      interferenceCoordinationGroup: '',
      nrqzValidated: false,
      nrqzValidation: {
        caseId: '',
        cpiId: '',
        latitude: '',
        longitude: '',
        state: ''
      }
    },
    displayName: '',
    fccId: '',
    grantRangeAllowlists: [
      {}
    ],
    grants: [
      {
        channelType: '',
        expireTime: '',
        frequencyRange: {},
        grantId: '',
        lastHeartbeatTransmitExpireTime: '',
        maxEirp: '',
        moveList: [
          {
            dpaId: '',
            frequencyRange: {}
          }
        ],
        state: '',
        suspensionReason: []
      }
    ],
    name: '',
    preloadedConfig: {},
    serialNumber: '',
    state: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:signDevice');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:signDevice',
  headers: {'content-type': 'application/json'},
  data: {
    device: {
      activeConfig: {
        airInterface: {radioTechnology: '', supportedSpec: ''},
        callSign: '',
        category: '',
        installationParams: {
          antennaAzimuth: 0,
          antennaBeamwidth: 0,
          antennaDowntilt: 0,
          antennaGain: 0,
          antennaGainNewField: '',
          antennaModel: '',
          cpeCbsdIndication: false,
          eirpCapability: 0,
          eirpCapabilityNewField: '',
          height: '',
          heightType: '',
          horizontalAccuracy: '',
          indoorDeployment: false,
          latitude: '',
          longitude: '',
          verticalAccuracy: ''
        },
        isSigned: false,
        measurementCapabilities: [],
        model: {
          firmwareVersion: '',
          hardwareVersion: '',
          name: '',
          softwareVersion: '',
          vendor: ''
        },
        state: '',
        updateTime: '',
        userId: ''
      },
      currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
      deviceMetadata: {
        antennaModel: '',
        commonChannelGroup: '',
        interferenceCoordinationGroup: '',
        nrqzValidated: false,
        nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
      },
      displayName: '',
      fccId: '',
      grantRangeAllowlists: [{}],
      grants: [
        {
          channelType: '',
          expireTime: '',
          frequencyRange: {},
          grantId: '',
          lastHeartbeatTransmitExpireTime: '',
          maxEirp: '',
          moveList: [{dpaId: '', frequencyRange: {}}],
          state: '',
          suspensionReason: []
        }
      ],
      name: '',
      preloadedConfig: {},
      serialNumber: '',
      state: ''
    }
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:name:signDevice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"device":{"activeConfig":{"airInterface":{"radioTechnology":"","supportedSpec":""},"callSign":"","category":"","installationParams":{"antennaAzimuth":0,"antennaBeamwidth":0,"antennaDowntilt":0,"antennaGain":0,"antennaGainNewField":"","antennaModel":"","cpeCbsdIndication":false,"eirpCapability":0,"eirpCapabilityNewField":"","height":"","heightType":"","horizontalAccuracy":"","indoorDeployment":false,"latitude":"","longitude":"","verticalAccuracy":""},"isSigned":false,"measurementCapabilities":[],"model":{"firmwareVersion":"","hardwareVersion":"","name":"","softwareVersion":"","vendor":""},"state":"","updateTime":"","userId":""},"currentChannels":[{"frequencyRange":{"highFrequencyMhz":"","lowFrequencyMhz":""},"score":""}],"deviceMetadata":{"antennaModel":"","commonChannelGroup":"","interferenceCoordinationGroup":"","nrqzValidated":false,"nrqzValidation":{"caseId":"","cpiId":"","latitude":"","longitude":"","state":""}},"displayName":"","fccId":"","grantRangeAllowlists":[{}],"grants":[{"channelType":"","expireTime":"","frequencyRange":{},"grantId":"","lastHeartbeatTransmitExpireTime":"","maxEirp":"","moveList":[{"dpaId":"","frequencyRange":{}}],"state":"","suspensionReason":[]}],"name":"","preloadedConfig":{},"serialNumber":"","state":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:name:signDevice',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "device": {\n    "activeConfig": {\n      "airInterface": {\n        "radioTechnology": "",\n        "supportedSpec": ""\n      },\n      "callSign": "",\n      "category": "",\n      "installationParams": {\n        "antennaAzimuth": 0,\n        "antennaBeamwidth": 0,\n        "antennaDowntilt": 0,\n        "antennaGain": 0,\n        "antennaGainNewField": "",\n        "antennaModel": "",\n        "cpeCbsdIndication": false,\n        "eirpCapability": 0,\n        "eirpCapabilityNewField": "",\n        "height": "",\n        "heightType": "",\n        "horizontalAccuracy": "",\n        "indoorDeployment": false,\n        "latitude": "",\n        "longitude": "",\n        "verticalAccuracy": ""\n      },\n      "isSigned": false,\n      "measurementCapabilities": [],\n      "model": {\n        "firmwareVersion": "",\n        "hardwareVersion": "",\n        "name": "",\n        "softwareVersion": "",\n        "vendor": ""\n      },\n      "state": "",\n      "updateTime": "",\n      "userId": ""\n    },\n    "currentChannels": [\n      {\n        "frequencyRange": {\n          "highFrequencyMhz": "",\n          "lowFrequencyMhz": ""\n        },\n        "score": ""\n      }\n    ],\n    "deviceMetadata": {\n      "antennaModel": "",\n      "commonChannelGroup": "",\n      "interferenceCoordinationGroup": "",\n      "nrqzValidated": false,\n      "nrqzValidation": {\n        "caseId": "",\n        "cpiId": "",\n        "latitude": "",\n        "longitude": "",\n        "state": ""\n      }\n    },\n    "displayName": "",\n    "fccId": "",\n    "grantRangeAllowlists": [\n      {}\n    ],\n    "grants": [\n      {\n        "channelType": "",\n        "expireTime": "",\n        "frequencyRange": {},\n        "grantId": "",\n        "lastHeartbeatTransmitExpireTime": "",\n        "maxEirp": "",\n        "moveList": [\n          {\n            "dpaId": "",\n            "frequencyRange": {}\n          }\n        ],\n        "state": "",\n        "suspensionReason": []\n      }\n    ],\n    "name": "",\n    "preloadedConfig": {},\n    "serialNumber": "",\n    "state": ""\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  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:signDevice")
  .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/v1alpha1/:name:signDevice',
  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({
  device: {
    activeConfig: {
      airInterface: {radioTechnology: '', supportedSpec: ''},
      callSign: '',
      category: '',
      installationParams: {
        antennaAzimuth: 0,
        antennaBeamwidth: 0,
        antennaDowntilt: 0,
        antennaGain: 0,
        antennaGainNewField: '',
        antennaModel: '',
        cpeCbsdIndication: false,
        eirpCapability: 0,
        eirpCapabilityNewField: '',
        height: '',
        heightType: '',
        horizontalAccuracy: '',
        indoorDeployment: false,
        latitude: '',
        longitude: '',
        verticalAccuracy: ''
      },
      isSigned: false,
      measurementCapabilities: [],
      model: {
        firmwareVersion: '',
        hardwareVersion: '',
        name: '',
        softwareVersion: '',
        vendor: ''
      },
      state: '',
      updateTime: '',
      userId: ''
    },
    currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
    deviceMetadata: {
      antennaModel: '',
      commonChannelGroup: '',
      interferenceCoordinationGroup: '',
      nrqzValidated: false,
      nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
    },
    displayName: '',
    fccId: '',
    grantRangeAllowlists: [{}],
    grants: [
      {
        channelType: '',
        expireTime: '',
        frequencyRange: {},
        grantId: '',
        lastHeartbeatTransmitExpireTime: '',
        maxEirp: '',
        moveList: [{dpaId: '', frequencyRange: {}}],
        state: '',
        suspensionReason: []
      }
    ],
    name: '',
    preloadedConfig: {},
    serialNumber: '',
    state: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:signDevice',
  headers: {'content-type': 'application/json'},
  body: {
    device: {
      activeConfig: {
        airInterface: {radioTechnology: '', supportedSpec: ''},
        callSign: '',
        category: '',
        installationParams: {
          antennaAzimuth: 0,
          antennaBeamwidth: 0,
          antennaDowntilt: 0,
          antennaGain: 0,
          antennaGainNewField: '',
          antennaModel: '',
          cpeCbsdIndication: false,
          eirpCapability: 0,
          eirpCapabilityNewField: '',
          height: '',
          heightType: '',
          horizontalAccuracy: '',
          indoorDeployment: false,
          latitude: '',
          longitude: '',
          verticalAccuracy: ''
        },
        isSigned: false,
        measurementCapabilities: [],
        model: {
          firmwareVersion: '',
          hardwareVersion: '',
          name: '',
          softwareVersion: '',
          vendor: ''
        },
        state: '',
        updateTime: '',
        userId: ''
      },
      currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
      deviceMetadata: {
        antennaModel: '',
        commonChannelGroup: '',
        interferenceCoordinationGroup: '',
        nrqzValidated: false,
        nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
      },
      displayName: '',
      fccId: '',
      grantRangeAllowlists: [{}],
      grants: [
        {
          channelType: '',
          expireTime: '',
          frequencyRange: {},
          grantId: '',
          lastHeartbeatTransmitExpireTime: '',
          maxEirp: '',
          moveList: [{dpaId: '', frequencyRange: {}}],
          state: '',
          suspensionReason: []
        }
      ],
      name: '',
      preloadedConfig: {},
      serialNumber: '',
      state: ''
    }
  },
  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}}/v1alpha1/:name:signDevice');

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

req.type('json');
req.send({
  device: {
    activeConfig: {
      airInterface: {
        radioTechnology: '',
        supportedSpec: ''
      },
      callSign: '',
      category: '',
      installationParams: {
        antennaAzimuth: 0,
        antennaBeamwidth: 0,
        antennaDowntilt: 0,
        antennaGain: 0,
        antennaGainNewField: '',
        antennaModel: '',
        cpeCbsdIndication: false,
        eirpCapability: 0,
        eirpCapabilityNewField: '',
        height: '',
        heightType: '',
        horizontalAccuracy: '',
        indoorDeployment: false,
        latitude: '',
        longitude: '',
        verticalAccuracy: ''
      },
      isSigned: false,
      measurementCapabilities: [],
      model: {
        firmwareVersion: '',
        hardwareVersion: '',
        name: '',
        softwareVersion: '',
        vendor: ''
      },
      state: '',
      updateTime: '',
      userId: ''
    },
    currentChannels: [
      {
        frequencyRange: {
          highFrequencyMhz: '',
          lowFrequencyMhz: ''
        },
        score: ''
      }
    ],
    deviceMetadata: {
      antennaModel: '',
      commonChannelGroup: '',
      interferenceCoordinationGroup: '',
      nrqzValidated: false,
      nrqzValidation: {
        caseId: '',
        cpiId: '',
        latitude: '',
        longitude: '',
        state: ''
      }
    },
    displayName: '',
    fccId: '',
    grantRangeAllowlists: [
      {}
    ],
    grants: [
      {
        channelType: '',
        expireTime: '',
        frequencyRange: {},
        grantId: '',
        lastHeartbeatTransmitExpireTime: '',
        maxEirp: '',
        moveList: [
          {
            dpaId: '',
            frequencyRange: {}
          }
        ],
        state: '',
        suspensionReason: []
      }
    ],
    name: '',
    preloadedConfig: {},
    serialNumber: '',
    state: ''
  }
});

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}}/v1alpha1/:name:signDevice',
  headers: {'content-type': 'application/json'},
  data: {
    device: {
      activeConfig: {
        airInterface: {radioTechnology: '', supportedSpec: ''},
        callSign: '',
        category: '',
        installationParams: {
          antennaAzimuth: 0,
          antennaBeamwidth: 0,
          antennaDowntilt: 0,
          antennaGain: 0,
          antennaGainNewField: '',
          antennaModel: '',
          cpeCbsdIndication: false,
          eirpCapability: 0,
          eirpCapabilityNewField: '',
          height: '',
          heightType: '',
          horizontalAccuracy: '',
          indoorDeployment: false,
          latitude: '',
          longitude: '',
          verticalAccuracy: ''
        },
        isSigned: false,
        measurementCapabilities: [],
        model: {
          firmwareVersion: '',
          hardwareVersion: '',
          name: '',
          softwareVersion: '',
          vendor: ''
        },
        state: '',
        updateTime: '',
        userId: ''
      },
      currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
      deviceMetadata: {
        antennaModel: '',
        commonChannelGroup: '',
        interferenceCoordinationGroup: '',
        nrqzValidated: false,
        nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
      },
      displayName: '',
      fccId: '',
      grantRangeAllowlists: [{}],
      grants: [
        {
          channelType: '',
          expireTime: '',
          frequencyRange: {},
          grantId: '',
          lastHeartbeatTransmitExpireTime: '',
          maxEirp: '',
          moveList: [{dpaId: '', frequencyRange: {}}],
          state: '',
          suspensionReason: []
        }
      ],
      name: '',
      preloadedConfig: {},
      serialNumber: '',
      state: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:signDevice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"device":{"activeConfig":{"airInterface":{"radioTechnology":"","supportedSpec":""},"callSign":"","category":"","installationParams":{"antennaAzimuth":0,"antennaBeamwidth":0,"antennaDowntilt":0,"antennaGain":0,"antennaGainNewField":"","antennaModel":"","cpeCbsdIndication":false,"eirpCapability":0,"eirpCapabilityNewField":"","height":"","heightType":"","horizontalAccuracy":"","indoorDeployment":false,"latitude":"","longitude":"","verticalAccuracy":""},"isSigned":false,"measurementCapabilities":[],"model":{"firmwareVersion":"","hardwareVersion":"","name":"","softwareVersion":"","vendor":""},"state":"","updateTime":"","userId":""},"currentChannels":[{"frequencyRange":{"highFrequencyMhz":"","lowFrequencyMhz":""},"score":""}],"deviceMetadata":{"antennaModel":"","commonChannelGroup":"","interferenceCoordinationGroup":"","nrqzValidated":false,"nrqzValidation":{"caseId":"","cpiId":"","latitude":"","longitude":"","state":""}},"displayName":"","fccId":"","grantRangeAllowlists":[{}],"grants":[{"channelType":"","expireTime":"","frequencyRange":{},"grantId":"","lastHeartbeatTransmitExpireTime":"","maxEirp":"","moveList":[{"dpaId":"","frequencyRange":{}}],"state":"","suspensionReason":[]}],"name":"","preloadedConfig":{},"serialNumber":"","state":""}}'
};

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 = @{ @"device": @{ @"activeConfig": @{ @"airInterface": @{ @"radioTechnology": @"", @"supportedSpec": @"" }, @"callSign": @"", @"category": @"", @"installationParams": @{ @"antennaAzimuth": @0, @"antennaBeamwidth": @0, @"antennaDowntilt": @0, @"antennaGain": @0, @"antennaGainNewField": @"", @"antennaModel": @"", @"cpeCbsdIndication": @NO, @"eirpCapability": @0, @"eirpCapabilityNewField": @"", @"height": @"", @"heightType": @"", @"horizontalAccuracy": @"", @"indoorDeployment": @NO, @"latitude": @"", @"longitude": @"", @"verticalAccuracy": @"" }, @"isSigned": @NO, @"measurementCapabilities": @[  ], @"model": @{ @"firmwareVersion": @"", @"hardwareVersion": @"", @"name": @"", @"softwareVersion": @"", @"vendor": @"" }, @"state": @"", @"updateTime": @"", @"userId": @"" }, @"currentChannels": @[ @{ @"frequencyRange": @{ @"highFrequencyMhz": @"", @"lowFrequencyMhz": @"" }, @"score": @"" } ], @"deviceMetadata": @{ @"antennaModel": @"", @"commonChannelGroup": @"", @"interferenceCoordinationGroup": @"", @"nrqzValidated": @NO, @"nrqzValidation": @{ @"caseId": @"", @"cpiId": @"", @"latitude": @"", @"longitude": @"", @"state": @"" } }, @"displayName": @"", @"fccId": @"", @"grantRangeAllowlists": @[ @{  } ], @"grants": @[ @{ @"channelType": @"", @"expireTime": @"", @"frequencyRange": @{  }, @"grantId": @"", @"lastHeartbeatTransmitExpireTime": @"", @"maxEirp": @"", @"moveList": @[ @{ @"dpaId": @"", @"frequencyRange": @{  } } ], @"state": @"", @"suspensionReason": @[  ] } ], @"name": @"", @"preloadedConfig": @{  }, @"serialNumber": @"", @"state": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:signDevice"]
                                                       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}}/v1alpha1/:name:signDevice" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:signDevice",
  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([
    'device' => [
        'activeConfig' => [
                'airInterface' => [
                                'radioTechnology' => '',
                                'supportedSpec' => ''
                ],
                'callSign' => '',
                'category' => '',
                'installationParams' => [
                                'antennaAzimuth' => 0,
                                'antennaBeamwidth' => 0,
                                'antennaDowntilt' => 0,
                                'antennaGain' => 0,
                                'antennaGainNewField' => '',
                                'antennaModel' => '',
                                'cpeCbsdIndication' => null,
                                'eirpCapability' => 0,
                                'eirpCapabilityNewField' => '',
                                'height' => '',
                                'heightType' => '',
                                'horizontalAccuracy' => '',
                                'indoorDeployment' => null,
                                'latitude' => '',
                                'longitude' => '',
                                'verticalAccuracy' => ''
                ],
                'isSigned' => null,
                'measurementCapabilities' => [
                                
                ],
                'model' => [
                                'firmwareVersion' => '',
                                'hardwareVersion' => '',
                                'name' => '',
                                'softwareVersion' => '',
                                'vendor' => ''
                ],
                'state' => '',
                'updateTime' => '',
                'userId' => ''
        ],
        'currentChannels' => [
                [
                                'frequencyRange' => [
                                                                'highFrequencyMhz' => '',
                                                                'lowFrequencyMhz' => ''
                                ],
                                'score' => ''
                ]
        ],
        'deviceMetadata' => [
                'antennaModel' => '',
                'commonChannelGroup' => '',
                'interferenceCoordinationGroup' => '',
                'nrqzValidated' => null,
                'nrqzValidation' => [
                                'caseId' => '',
                                'cpiId' => '',
                                'latitude' => '',
                                'longitude' => '',
                                'state' => ''
                ]
        ],
        'displayName' => '',
        'fccId' => '',
        'grantRangeAllowlists' => [
                [
                                
                ]
        ],
        'grants' => [
                [
                                'channelType' => '',
                                'expireTime' => '',
                                'frequencyRange' => [
                                                                
                                ],
                                'grantId' => '',
                                'lastHeartbeatTransmitExpireTime' => '',
                                'maxEirp' => '',
                                'moveList' => [
                                                                [
                                                                                                                                'dpaId' => '',
                                                                                                                                'frequencyRange' => [
                                                                                                                                                                                                                                                                
                                                                                                                                ]
                                                                ]
                                ],
                                'state' => '',
                                'suspensionReason' => [
                                                                
                                ]
                ]
        ],
        'name' => '',
        'preloadedConfig' => [
                
        ],
        'serialNumber' => '',
        'state' => ''
    ]
  ]),
  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}}/v1alpha1/:name:signDevice', [
  'body' => '{
  "device": {
    "activeConfig": {
      "airInterface": {
        "radioTechnology": "",
        "supportedSpec": ""
      },
      "callSign": "",
      "category": "",
      "installationParams": {
        "antennaAzimuth": 0,
        "antennaBeamwidth": 0,
        "antennaDowntilt": 0,
        "antennaGain": 0,
        "antennaGainNewField": "",
        "antennaModel": "",
        "cpeCbsdIndication": false,
        "eirpCapability": 0,
        "eirpCapabilityNewField": "",
        "height": "",
        "heightType": "",
        "horizontalAccuracy": "",
        "indoorDeployment": false,
        "latitude": "",
        "longitude": "",
        "verticalAccuracy": ""
      },
      "isSigned": false,
      "measurementCapabilities": [],
      "model": {
        "firmwareVersion": "",
        "hardwareVersion": "",
        "name": "",
        "softwareVersion": "",
        "vendor": ""
      },
      "state": "",
      "updateTime": "",
      "userId": ""
    },
    "currentChannels": [
      {
        "frequencyRange": {
          "highFrequencyMhz": "",
          "lowFrequencyMhz": ""
        },
        "score": ""
      }
    ],
    "deviceMetadata": {
      "antennaModel": "",
      "commonChannelGroup": "",
      "interferenceCoordinationGroup": "",
      "nrqzValidated": false,
      "nrqzValidation": {
        "caseId": "",
        "cpiId": "",
        "latitude": "",
        "longitude": "",
        "state": ""
      }
    },
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [
      {}
    ],
    "grants": [
      {
        "channelType": "",
        "expireTime": "",
        "frequencyRange": {},
        "grantId": "",
        "lastHeartbeatTransmitExpireTime": "",
        "maxEirp": "",
        "moveList": [
          {
            "dpaId": "",
            "frequencyRange": {}
          }
        ],
        "state": "",
        "suspensionReason": []
      }
    ],
    "name": "",
    "preloadedConfig": {},
    "serialNumber": "",
    "state": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:signDevice');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'device' => [
    'activeConfig' => [
        'airInterface' => [
                'radioTechnology' => '',
                'supportedSpec' => ''
        ],
        'callSign' => '',
        'category' => '',
        'installationParams' => [
                'antennaAzimuth' => 0,
                'antennaBeamwidth' => 0,
                'antennaDowntilt' => 0,
                'antennaGain' => 0,
                'antennaGainNewField' => '',
                'antennaModel' => '',
                'cpeCbsdIndication' => null,
                'eirpCapability' => 0,
                'eirpCapabilityNewField' => '',
                'height' => '',
                'heightType' => '',
                'horizontalAccuracy' => '',
                'indoorDeployment' => null,
                'latitude' => '',
                'longitude' => '',
                'verticalAccuracy' => ''
        ],
        'isSigned' => null,
        'measurementCapabilities' => [
                
        ],
        'model' => [
                'firmwareVersion' => '',
                'hardwareVersion' => '',
                'name' => '',
                'softwareVersion' => '',
                'vendor' => ''
        ],
        'state' => '',
        'updateTime' => '',
        'userId' => ''
    ],
    'currentChannels' => [
        [
                'frequencyRange' => [
                                'highFrequencyMhz' => '',
                                'lowFrequencyMhz' => ''
                ],
                'score' => ''
        ]
    ],
    'deviceMetadata' => [
        'antennaModel' => '',
        'commonChannelGroup' => '',
        'interferenceCoordinationGroup' => '',
        'nrqzValidated' => null,
        'nrqzValidation' => [
                'caseId' => '',
                'cpiId' => '',
                'latitude' => '',
                'longitude' => '',
                'state' => ''
        ]
    ],
    'displayName' => '',
    'fccId' => '',
    'grantRangeAllowlists' => [
        [
                
        ]
    ],
    'grants' => [
        [
                'channelType' => '',
                'expireTime' => '',
                'frequencyRange' => [
                                
                ],
                'grantId' => '',
                'lastHeartbeatTransmitExpireTime' => '',
                'maxEirp' => '',
                'moveList' => [
                                [
                                                                'dpaId' => '',
                                                                'frequencyRange' => [
                                                                                                                                
                                                                ]
                                ]
                ],
                'state' => '',
                'suspensionReason' => [
                                
                ]
        ]
    ],
    'name' => '',
    'preloadedConfig' => [
        
    ],
    'serialNumber' => '',
    'state' => ''
  ]
]));

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

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

append(json_encode([
  'device' => [
    'activeConfig' => [
        'airInterface' => [
                'radioTechnology' => '',
                'supportedSpec' => ''
        ],
        'callSign' => '',
        'category' => '',
        'installationParams' => [
                'antennaAzimuth' => 0,
                'antennaBeamwidth' => 0,
                'antennaDowntilt' => 0,
                'antennaGain' => 0,
                'antennaGainNewField' => '',
                'antennaModel' => '',
                'cpeCbsdIndication' => null,
                'eirpCapability' => 0,
                'eirpCapabilityNewField' => '',
                'height' => '',
                'heightType' => '',
                'horizontalAccuracy' => '',
                'indoorDeployment' => null,
                'latitude' => '',
                'longitude' => '',
                'verticalAccuracy' => ''
        ],
        'isSigned' => null,
        'measurementCapabilities' => [
                
        ],
        'model' => [
                'firmwareVersion' => '',
                'hardwareVersion' => '',
                'name' => '',
                'softwareVersion' => '',
                'vendor' => ''
        ],
        'state' => '',
        'updateTime' => '',
        'userId' => ''
    ],
    'currentChannels' => [
        [
                'frequencyRange' => [
                                'highFrequencyMhz' => '',
                                'lowFrequencyMhz' => ''
                ],
                'score' => ''
        ]
    ],
    'deviceMetadata' => [
        'antennaModel' => '',
        'commonChannelGroup' => '',
        'interferenceCoordinationGroup' => '',
        'nrqzValidated' => null,
        'nrqzValidation' => [
                'caseId' => '',
                'cpiId' => '',
                'latitude' => '',
                'longitude' => '',
                'state' => ''
        ]
    ],
    'displayName' => '',
    'fccId' => '',
    'grantRangeAllowlists' => [
        [
                
        ]
    ],
    'grants' => [
        [
                'channelType' => '',
                'expireTime' => '',
                'frequencyRange' => [
                                
                ],
                'grantId' => '',
                'lastHeartbeatTransmitExpireTime' => '',
                'maxEirp' => '',
                'moveList' => [
                                [
                                                                'dpaId' => '',
                                                                'frequencyRange' => [
                                                                                                                                
                                                                ]
                                ]
                ],
                'state' => '',
                'suspensionReason' => [
                                
                ]
        ]
    ],
    'name' => '',
    'preloadedConfig' => [
        
    ],
    'serialNumber' => '',
    'state' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:signDevice');
$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}}/v1alpha1/:name:signDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "device": {
    "activeConfig": {
      "airInterface": {
        "radioTechnology": "",
        "supportedSpec": ""
      },
      "callSign": "",
      "category": "",
      "installationParams": {
        "antennaAzimuth": 0,
        "antennaBeamwidth": 0,
        "antennaDowntilt": 0,
        "antennaGain": 0,
        "antennaGainNewField": "",
        "antennaModel": "",
        "cpeCbsdIndication": false,
        "eirpCapability": 0,
        "eirpCapabilityNewField": "",
        "height": "",
        "heightType": "",
        "horizontalAccuracy": "",
        "indoorDeployment": false,
        "latitude": "",
        "longitude": "",
        "verticalAccuracy": ""
      },
      "isSigned": false,
      "measurementCapabilities": [],
      "model": {
        "firmwareVersion": "",
        "hardwareVersion": "",
        "name": "",
        "softwareVersion": "",
        "vendor": ""
      },
      "state": "",
      "updateTime": "",
      "userId": ""
    },
    "currentChannels": [
      {
        "frequencyRange": {
          "highFrequencyMhz": "",
          "lowFrequencyMhz": ""
        },
        "score": ""
      }
    ],
    "deviceMetadata": {
      "antennaModel": "",
      "commonChannelGroup": "",
      "interferenceCoordinationGroup": "",
      "nrqzValidated": false,
      "nrqzValidation": {
        "caseId": "",
        "cpiId": "",
        "latitude": "",
        "longitude": "",
        "state": ""
      }
    },
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [
      {}
    ],
    "grants": [
      {
        "channelType": "",
        "expireTime": "",
        "frequencyRange": {},
        "grantId": "",
        "lastHeartbeatTransmitExpireTime": "",
        "maxEirp": "",
        "moveList": [
          {
            "dpaId": "",
            "frequencyRange": {}
          }
        ],
        "state": "",
        "suspensionReason": []
      }
    ],
    "name": "",
    "preloadedConfig": {},
    "serialNumber": "",
    "state": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:signDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "device": {
    "activeConfig": {
      "airInterface": {
        "radioTechnology": "",
        "supportedSpec": ""
      },
      "callSign": "",
      "category": "",
      "installationParams": {
        "antennaAzimuth": 0,
        "antennaBeamwidth": 0,
        "antennaDowntilt": 0,
        "antennaGain": 0,
        "antennaGainNewField": "",
        "antennaModel": "",
        "cpeCbsdIndication": false,
        "eirpCapability": 0,
        "eirpCapabilityNewField": "",
        "height": "",
        "heightType": "",
        "horizontalAccuracy": "",
        "indoorDeployment": false,
        "latitude": "",
        "longitude": "",
        "verticalAccuracy": ""
      },
      "isSigned": false,
      "measurementCapabilities": [],
      "model": {
        "firmwareVersion": "",
        "hardwareVersion": "",
        "name": "",
        "softwareVersion": "",
        "vendor": ""
      },
      "state": "",
      "updateTime": "",
      "userId": ""
    },
    "currentChannels": [
      {
        "frequencyRange": {
          "highFrequencyMhz": "",
          "lowFrequencyMhz": ""
        },
        "score": ""
      }
    ],
    "deviceMetadata": {
      "antennaModel": "",
      "commonChannelGroup": "",
      "interferenceCoordinationGroup": "",
      "nrqzValidated": false,
      "nrqzValidation": {
        "caseId": "",
        "cpiId": "",
        "latitude": "",
        "longitude": "",
        "state": ""
      }
    },
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [
      {}
    ],
    "grants": [
      {
        "channelType": "",
        "expireTime": "",
        "frequencyRange": {},
        "grantId": "",
        "lastHeartbeatTransmitExpireTime": "",
        "maxEirp": "",
        "moveList": [
          {
            "dpaId": "",
            "frequencyRange": {}
          }
        ],
        "state": "",
        "suspensionReason": []
      }
    ],
    "name": "",
    "preloadedConfig": {},
    "serialNumber": "",
    "state": ""
  }
}'

import http.client

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

payload = "{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:name:signDevice", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:signDevice"

payload = { "device": {
        "activeConfig": {
            "airInterface": {
                "radioTechnology": "",
                "supportedSpec": ""
            },
            "callSign": "",
            "category": "",
            "installationParams": {
                "antennaAzimuth": 0,
                "antennaBeamwidth": 0,
                "antennaDowntilt": 0,
                "antennaGain": 0,
                "antennaGainNewField": "",
                "antennaModel": "",
                "cpeCbsdIndication": False,
                "eirpCapability": 0,
                "eirpCapabilityNewField": "",
                "height": "",
                "heightType": "",
                "horizontalAccuracy": "",
                "indoorDeployment": False,
                "latitude": "",
                "longitude": "",
                "verticalAccuracy": ""
            },
            "isSigned": False,
            "measurementCapabilities": [],
            "model": {
                "firmwareVersion": "",
                "hardwareVersion": "",
                "name": "",
                "softwareVersion": "",
                "vendor": ""
            },
            "state": "",
            "updateTime": "",
            "userId": ""
        },
        "currentChannels": [
            {
                "frequencyRange": {
                    "highFrequencyMhz": "",
                    "lowFrequencyMhz": ""
                },
                "score": ""
            }
        ],
        "deviceMetadata": {
            "antennaModel": "",
            "commonChannelGroup": "",
            "interferenceCoordinationGroup": "",
            "nrqzValidated": False,
            "nrqzValidation": {
                "caseId": "",
                "cpiId": "",
                "latitude": "",
                "longitude": "",
                "state": ""
            }
        },
        "displayName": "",
        "fccId": "",
        "grantRangeAllowlists": [{}],
        "grants": [
            {
                "channelType": "",
                "expireTime": "",
                "frequencyRange": {},
                "grantId": "",
                "lastHeartbeatTransmitExpireTime": "",
                "maxEirp": "",
                "moveList": [
                    {
                        "dpaId": "",
                        "frequencyRange": {}
                    }
                ],
                "state": "",
                "suspensionReason": []
            }
        ],
        "name": "",
        "preloadedConfig": {},
        "serialNumber": "",
        "state": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:signDevice"

payload <- "{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\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}}/v1alpha1/:name:signDevice")

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  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\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/v1alpha1/:name:signDevice') do |req|
  req.body = "{\n  \"device\": {\n    \"activeConfig\": {\n      \"airInterface\": {\n        \"radioTechnology\": \"\",\n        \"supportedSpec\": \"\"\n      },\n      \"callSign\": \"\",\n      \"category\": \"\",\n      \"installationParams\": {\n        \"antennaAzimuth\": 0,\n        \"antennaBeamwidth\": 0,\n        \"antennaDowntilt\": 0,\n        \"antennaGain\": 0,\n        \"antennaGainNewField\": \"\",\n        \"antennaModel\": \"\",\n        \"cpeCbsdIndication\": false,\n        \"eirpCapability\": 0,\n        \"eirpCapabilityNewField\": \"\",\n        \"height\": \"\",\n        \"heightType\": \"\",\n        \"horizontalAccuracy\": \"\",\n        \"indoorDeployment\": false,\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"verticalAccuracy\": \"\"\n      },\n      \"isSigned\": false,\n      \"measurementCapabilities\": [],\n      \"model\": {\n        \"firmwareVersion\": \"\",\n        \"hardwareVersion\": \"\",\n        \"name\": \"\",\n        \"softwareVersion\": \"\",\n        \"vendor\": \"\"\n      },\n      \"state\": \"\",\n      \"updateTime\": \"\",\n      \"userId\": \"\"\n    },\n    \"currentChannels\": [\n      {\n        \"frequencyRange\": {\n          \"highFrequencyMhz\": \"\",\n          \"lowFrequencyMhz\": \"\"\n        },\n        \"score\": \"\"\n      }\n    ],\n    \"deviceMetadata\": {\n      \"antennaModel\": \"\",\n      \"commonChannelGroup\": \"\",\n      \"interferenceCoordinationGroup\": \"\",\n      \"nrqzValidated\": false,\n      \"nrqzValidation\": {\n        \"caseId\": \"\",\n        \"cpiId\": \"\",\n        \"latitude\": \"\",\n        \"longitude\": \"\",\n        \"state\": \"\"\n      }\n    },\n    \"displayName\": \"\",\n    \"fccId\": \"\",\n    \"grantRangeAllowlists\": [\n      {}\n    ],\n    \"grants\": [\n      {\n        \"channelType\": \"\",\n        \"expireTime\": \"\",\n        \"frequencyRange\": {},\n        \"grantId\": \"\",\n        \"lastHeartbeatTransmitExpireTime\": \"\",\n        \"maxEirp\": \"\",\n        \"moveList\": [\n          {\n            \"dpaId\": \"\",\n            \"frequencyRange\": {}\n          }\n        ],\n        \"state\": \"\",\n        \"suspensionReason\": []\n      }\n    ],\n    \"name\": \"\",\n    \"preloadedConfig\": {},\n    \"serialNumber\": \"\",\n    \"state\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"device": json!({
            "activeConfig": json!({
                "airInterface": json!({
                    "radioTechnology": "",
                    "supportedSpec": ""
                }),
                "callSign": "",
                "category": "",
                "installationParams": json!({
                    "antennaAzimuth": 0,
                    "antennaBeamwidth": 0,
                    "antennaDowntilt": 0,
                    "antennaGain": 0,
                    "antennaGainNewField": "",
                    "antennaModel": "",
                    "cpeCbsdIndication": false,
                    "eirpCapability": 0,
                    "eirpCapabilityNewField": "",
                    "height": "",
                    "heightType": "",
                    "horizontalAccuracy": "",
                    "indoorDeployment": false,
                    "latitude": "",
                    "longitude": "",
                    "verticalAccuracy": ""
                }),
                "isSigned": false,
                "measurementCapabilities": (),
                "model": json!({
                    "firmwareVersion": "",
                    "hardwareVersion": "",
                    "name": "",
                    "softwareVersion": "",
                    "vendor": ""
                }),
                "state": "",
                "updateTime": "",
                "userId": ""
            }),
            "currentChannels": (
                json!({
                    "frequencyRange": json!({
                        "highFrequencyMhz": "",
                        "lowFrequencyMhz": ""
                    }),
                    "score": ""
                })
            ),
            "deviceMetadata": json!({
                "antennaModel": "",
                "commonChannelGroup": "",
                "interferenceCoordinationGroup": "",
                "nrqzValidated": false,
                "nrqzValidation": json!({
                    "caseId": "",
                    "cpiId": "",
                    "latitude": "",
                    "longitude": "",
                    "state": ""
                })
            }),
            "displayName": "",
            "fccId": "",
            "grantRangeAllowlists": (json!({})),
            "grants": (
                json!({
                    "channelType": "",
                    "expireTime": "",
                    "frequencyRange": json!({}),
                    "grantId": "",
                    "lastHeartbeatTransmitExpireTime": "",
                    "maxEirp": "",
                    "moveList": (
                        json!({
                            "dpaId": "",
                            "frequencyRange": json!({})
                        })
                    ),
                    "state": "",
                    "suspensionReason": ()
                })
            ),
            "name": "",
            "preloadedConfig": json!({}),
            "serialNumber": "",
            "state": ""
        })});

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

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

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

    dbg!(results);
}

echo '{
  "device": {
    "activeConfig": {
      "airInterface": {
        "radioTechnology": "",
        "supportedSpec": ""
      },
      "callSign": "",
      "category": "",
      "installationParams": {
        "antennaAzimuth": 0,
        "antennaBeamwidth": 0,
        "antennaDowntilt": 0,
        "antennaGain": 0,
        "antennaGainNewField": "",
        "antennaModel": "",
        "cpeCbsdIndication": false,
        "eirpCapability": 0,
        "eirpCapabilityNewField": "",
        "height": "",
        "heightType": "",
        "horizontalAccuracy": "",
        "indoorDeployment": false,
        "latitude": "",
        "longitude": "",
        "verticalAccuracy": ""
      },
      "isSigned": false,
      "measurementCapabilities": [],
      "model": {
        "firmwareVersion": "",
        "hardwareVersion": "",
        "name": "",
        "softwareVersion": "",
        "vendor": ""
      },
      "state": "",
      "updateTime": "",
      "userId": ""
    },
    "currentChannels": [
      {
        "frequencyRange": {
          "highFrequencyMhz": "",
          "lowFrequencyMhz": ""
        },
        "score": ""
      }
    ],
    "deviceMetadata": {
      "antennaModel": "",
      "commonChannelGroup": "",
      "interferenceCoordinationGroup": "",
      "nrqzValidated": false,
      "nrqzValidation": {
        "caseId": "",
        "cpiId": "",
        "latitude": "",
        "longitude": "",
        "state": ""
      }
    },
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [
      {}
    ],
    "grants": [
      {
        "channelType": "",
        "expireTime": "",
        "frequencyRange": {},
        "grantId": "",
        "lastHeartbeatTransmitExpireTime": "",
        "maxEirp": "",
        "moveList": [
          {
            "dpaId": "",
            "frequencyRange": {}
          }
        ],
        "state": "",
        "suspensionReason": []
      }
    ],
    "name": "",
    "preloadedConfig": {},
    "serialNumber": "",
    "state": ""
  }
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:signDevice \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "device": {\n    "activeConfig": {\n      "airInterface": {\n        "radioTechnology": "",\n        "supportedSpec": ""\n      },\n      "callSign": "",\n      "category": "",\n      "installationParams": {\n        "antennaAzimuth": 0,\n        "antennaBeamwidth": 0,\n        "antennaDowntilt": 0,\n        "antennaGain": 0,\n        "antennaGainNewField": "",\n        "antennaModel": "",\n        "cpeCbsdIndication": false,\n        "eirpCapability": 0,\n        "eirpCapabilityNewField": "",\n        "height": "",\n        "heightType": "",\n        "horizontalAccuracy": "",\n        "indoorDeployment": false,\n        "latitude": "",\n        "longitude": "",\n        "verticalAccuracy": ""\n      },\n      "isSigned": false,\n      "measurementCapabilities": [],\n      "model": {\n        "firmwareVersion": "",\n        "hardwareVersion": "",\n        "name": "",\n        "softwareVersion": "",\n        "vendor": ""\n      },\n      "state": "",\n      "updateTime": "",\n      "userId": ""\n    },\n    "currentChannels": [\n      {\n        "frequencyRange": {\n          "highFrequencyMhz": "",\n          "lowFrequencyMhz": ""\n        },\n        "score": ""\n      }\n    ],\n    "deviceMetadata": {\n      "antennaModel": "",\n      "commonChannelGroup": "",\n      "interferenceCoordinationGroup": "",\n      "nrqzValidated": false,\n      "nrqzValidation": {\n        "caseId": "",\n        "cpiId": "",\n        "latitude": "",\n        "longitude": "",\n        "state": ""\n      }\n    },\n    "displayName": "",\n    "fccId": "",\n    "grantRangeAllowlists": [\n      {}\n    ],\n    "grants": [\n      {\n        "channelType": "",\n        "expireTime": "",\n        "frequencyRange": {},\n        "grantId": "",\n        "lastHeartbeatTransmitExpireTime": "",\n        "maxEirp": "",\n        "moveList": [\n          {\n            "dpaId": "",\n            "frequencyRange": {}\n          }\n        ],\n        "state": "",\n        "suspensionReason": []\n      }\n    ],\n    "name": "",\n    "preloadedConfig": {},\n    "serialNumber": "",\n    "state": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:signDevice

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["device": [
    "activeConfig": [
      "airInterface": [
        "radioTechnology": "",
        "supportedSpec": ""
      ],
      "callSign": "",
      "category": "",
      "installationParams": [
        "antennaAzimuth": 0,
        "antennaBeamwidth": 0,
        "antennaDowntilt": 0,
        "antennaGain": 0,
        "antennaGainNewField": "",
        "antennaModel": "",
        "cpeCbsdIndication": false,
        "eirpCapability": 0,
        "eirpCapabilityNewField": "",
        "height": "",
        "heightType": "",
        "horizontalAccuracy": "",
        "indoorDeployment": false,
        "latitude": "",
        "longitude": "",
        "verticalAccuracy": ""
      ],
      "isSigned": false,
      "measurementCapabilities": [],
      "model": [
        "firmwareVersion": "",
        "hardwareVersion": "",
        "name": "",
        "softwareVersion": "",
        "vendor": ""
      ],
      "state": "",
      "updateTime": "",
      "userId": ""
    ],
    "currentChannels": [
      [
        "frequencyRange": [
          "highFrequencyMhz": "",
          "lowFrequencyMhz": ""
        ],
        "score": ""
      ]
    ],
    "deviceMetadata": [
      "antennaModel": "",
      "commonChannelGroup": "",
      "interferenceCoordinationGroup": "",
      "nrqzValidated": false,
      "nrqzValidation": [
        "caseId": "",
        "cpiId": "",
        "latitude": "",
        "longitude": "",
        "state": ""
      ]
    ],
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [[]],
    "grants": [
      [
        "channelType": "",
        "expireTime": "",
        "frequencyRange": [],
        "grantId": "",
        "lastHeartbeatTransmitExpireTime": "",
        "maxEirp": "",
        "moveList": [
          [
            "dpaId": "",
            "frequencyRange": []
          ]
        ],
        "state": "",
        "suspensionReason": []
      ]
    ],
    "name": "",
    "preloadedConfig": [],
    "serialNumber": "",
    "state": ""
  ]] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name:updateSigned");

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  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1alpha1/:name:updateSigned" {:content-type :json
                                                                         :form-params {:encodedDevice ""
                                                                                       :installerId ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name:updateSigned"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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}}/v1alpha1/:name:updateSigned"),
    Content = new StringContent("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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}}/v1alpha1/:name:updateSigned");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:updateSigned"

	payload := strings.NewReader("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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/v1alpha1/:name:updateSigned HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "encodedDevice": "",
  "installerId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1alpha1/:name:updateSigned")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:updateSigned"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:updateSigned")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1alpha1/:name:updateSigned")
  .header("content-type", "application/json")
  .body("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  encodedDevice: '',
  installerId: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1alpha1/:name:updateSigned');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name:updateSigned',
  headers: {'content-type': 'application/json'},
  data: {encodedDevice: '', installerId: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/:name:updateSigned';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"encodedDevice":"","installerId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:name:updateSigned',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "encodedDevice": "",\n  "installerId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:updateSigned")
  .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/v1alpha1/:name:updateSigned',
  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({encodedDevice: '', installerId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name:updateSigned',
  headers: {'content-type': 'application/json'},
  body: {encodedDevice: '', installerId: ''},
  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}}/v1alpha1/:name:updateSigned');

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

req.type('json');
req.send({
  encodedDevice: '',
  installerId: ''
});

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}}/v1alpha1/:name:updateSigned',
  headers: {'content-type': 'application/json'},
  data: {encodedDevice: '', installerId: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:updateSigned';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"encodedDevice":"","installerId":""}'
};

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 = @{ @"encodedDevice": @"",
                              @"installerId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:name:updateSigned"]
                                                       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}}/v1alpha1/:name:updateSigned" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:name:updateSigned",
  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([
    'encodedDevice' => '',
    'installerId' => ''
  ]),
  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}}/v1alpha1/:name:updateSigned', [
  'body' => '{
  "encodedDevice": "",
  "installerId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:updateSigned');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

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

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

append(json_encode([
  'encodedDevice' => '',
  'installerId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:updateSigned');
$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}}/v1alpha1/:name:updateSigned' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "encodedDevice": "",
  "installerId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:updateSigned' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "encodedDevice": "",
  "installerId": ""
}'

import http.client

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

payload = "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1alpha1/:name:updateSigned", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:updateSigned"

payload = {
    "encodedDevice": "",
    "installerId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:updateSigned"

payload <- "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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}}/v1alpha1/:name:updateSigned")

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  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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/v1alpha1/:name:updateSigned') do |req|
  req.body = "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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}}/v1alpha1/:name:updateSigned";

    let payload = json!({
        "encodedDevice": "",
        "installerId": ""
    });

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

echo '{
  "encodedDevice": "",
  "installerId": ""
}' |  \
  http PATCH {{baseUrl}}/v1alpha1/:name:updateSigned \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "encodedDevice": "",\n  "installerId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:updateSigned

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1alpha1/:name")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/v1alpha1/:name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1alpha1/:name'};

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

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

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

val client = OkHttpClient()

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

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

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

const url = '{{baseUrl}}/v1alpha1/: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}}/v1alpha1/: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}}/v1alpha1/:name" in

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

 "{{baseUrl}}/v1alpha1/: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}}/v1alpha1/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1alpha1/:name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v1alpha1/:name")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/: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/v1alpha1/: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}}/v1alpha1/:name";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v1alpha1/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/deployments");

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  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/deployments" {:content-type :json
                                                                         :form-params {:displayName ""
                                                                                       :frns []
                                                                                       :name ""
                                                                                       :sasUserIds []}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/deployments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:parent/deployments"),
    Content = new StringContent("{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:parent/deployments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/deployments"

	payload := strings.NewReader("{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\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/v1alpha1/:parent/deployments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "displayName": "",
  "frns": [],
  "name": "",
  "sasUserIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/deployments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/deployments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\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  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/deployments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/deployments")
  .header("content-type", "application/json")
  .body("{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
  .asString();

const data = JSON.stringify({
  displayName: '',
  frns: [],
  name: '',
  sasUserIds: []
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/deployments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/deployments',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', frns: [], name: '', sasUserIds: []}
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/deployments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","frns":[],"name":"","sasUserIds":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:parent/deployments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "displayName": "",\n  "frns": [],\n  "name": "",\n  "sasUserIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/deployments")
  .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/v1alpha1/:parent/deployments',
  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({displayName: '', frns: [], name: '', sasUserIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/deployments',
  headers: {'content-type': 'application/json'},
  body: {displayName: '', frns: [], name: '', sasUserIds: []},
  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}}/v1alpha1/:parent/deployments');

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

req.type('json');
req.send({
  displayName: '',
  frns: [],
  name: '',
  sasUserIds: []
});

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}}/v1alpha1/:parent/deployments',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', frns: [], name: '', sasUserIds: []}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/deployments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","frns":[],"name":"","sasUserIds":[]}'
};

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 = @{ @"displayName": @"",
                              @"frns": @[  ],
                              @"name": @"",
                              @"sasUserIds": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:parent/deployments"]
                                                       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}}/v1alpha1/:parent/deployments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}" in

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

 "{{baseUrl}}/v1alpha1/:parent/deployments",
  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([
    'displayName' => '',
    'frns' => [
        
    ],
    'name' => '',
    'sasUserIds' => [
        
    ]
  ]),
  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}}/v1alpha1/:parent/deployments', [
  'body' => '{
  "displayName": "",
  "frns": [],
  "name": "",
  "sasUserIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/deployments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'displayName' => '',
  'frns' => [
    
  ],
  'name' => '',
  'sasUserIds' => [
    
  ]
]));

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

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

append(json_encode([
  'displayName' => '',
  'frns' => [
    
  ],
  'name' => '',
  'sasUserIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/deployments');
$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}}/v1alpha1/:parent/deployments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "frns": [],
  "name": "",
  "sasUserIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/deployments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "frns": [],
  "name": "",
  "sasUserIds": []
}'

import http.client

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

payload = "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/deployments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/deployments"

payload = {
    "displayName": "",
    "frns": [],
    "name": "",
    "sasUserIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/deployments"

payload <- "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:parent/deployments")

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  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\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/v1alpha1/:parent/deployments') do |req|
  req.body = "{\n  \"displayName\": \"\",\n  \"frns\": [],\n  \"name\": \"\",\n  \"sasUserIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "displayName": "",
        "frns": (),
        "name": "",
        "sasUserIds": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "displayName": "",
  "frns": [],
  "name": "",
  "sasUserIds": []
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/deployments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "displayName": "",\n  "frns": [],\n  "name": "",\n  "sasUserIds": []\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/deployments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "displayName": "",
  "frns": [],
  "name": "",
  "sasUserIds": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/deployments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/deployments")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/deployments"

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

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/deployments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/deployments"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:parent/deployments'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/deployments")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:parent/deployments');

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}}/v1alpha1/:parent/deployments'};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/deployments';
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}}/v1alpha1/:parent/deployments"]
                                                       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}}/v1alpha1/:parent/deployments" in

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

 "{{baseUrl}}/v1alpha1/:parent/deployments",
  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}}/v1alpha1/:parent/deployments');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/deployments');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/deployments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/deployments' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/deployments")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/deployments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/deployments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/deployments")

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/v1alpha1/:parent/deployments') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/deployments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/deployments

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/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  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/devices" {:content-type :json
                                                                     :form-params {:activeConfig {:airInterface {:radioTechnology ""
                                                                                                                 :supportedSpec ""}
                                                                                                  :callSign ""
                                                                                                  :category ""
                                                                                                  :installationParams {:antennaAzimuth 0
                                                                                                                       :antennaBeamwidth 0
                                                                                                                       :antennaDowntilt 0
                                                                                                                       :antennaGain 0
                                                                                                                       :antennaGainNewField ""
                                                                                                                       :antennaModel ""
                                                                                                                       :cpeCbsdIndication false
                                                                                                                       :eirpCapability 0
                                                                                                                       :eirpCapabilityNewField ""
                                                                                                                       :height ""
                                                                                                                       :heightType ""
                                                                                                                       :horizontalAccuracy ""
                                                                                                                       :indoorDeployment false
                                                                                                                       :latitude ""
                                                                                                                       :longitude ""
                                                                                                                       :verticalAccuracy ""}
                                                                                                  :isSigned false
                                                                                                  :measurementCapabilities []
                                                                                                  :model {:firmwareVersion ""
                                                                                                          :hardwareVersion ""
                                                                                                          :name ""
                                                                                                          :softwareVersion ""
                                                                                                          :vendor ""}
                                                                                                  :state ""
                                                                                                  :updateTime ""
                                                                                                  :userId ""}
                                                                                   :currentChannels [{:frequencyRange {:highFrequencyMhz ""
                                                                                                                       :lowFrequencyMhz ""}
                                                                                                      :score ""}]
                                                                                   :deviceMetadata {:antennaModel ""
                                                                                                    :commonChannelGroup ""
                                                                                                    :interferenceCoordinationGroup ""
                                                                                                    :nrqzValidated false
                                                                                                    :nrqzValidation {:caseId ""
                                                                                                                     :cpiId ""
                                                                                                                     :latitude ""
                                                                                                                     :longitude ""
                                                                                                                     :state ""}}
                                                                                   :displayName ""
                                                                                   :fccId ""
                                                                                   :grantRangeAllowlists [{}]
                                                                                   :grants [{:channelType ""
                                                                                             :expireTime ""
                                                                                             :frequencyRange {}
                                                                                             :grantId ""
                                                                                             :lastHeartbeatTransmitExpireTime ""
                                                                                             :maxEirp ""
                                                                                             :moveList [{:dpaId ""
                                                                                                         :frequencyRange {}}]
                                                                                             :state ""
                                                                                             :suspensionReason []}]
                                                                                   :name ""
                                                                                   :preloadedConfig {}
                                                                                   :serialNumber ""
                                                                                   :state ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/devices"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\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}}/v1alpha1/:parent/devices"),
    Content = new StringContent("{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\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}}/v1alpha1/:parent/devices");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/devices"

	payload := strings.NewReader("{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\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/v1alpha1/:parent/devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1828

{
  "activeConfig": {
    "airInterface": {
      "radioTechnology": "",
      "supportedSpec": ""
    },
    "callSign": "",
    "category": "",
    "installationParams": {
      "antennaAzimuth": 0,
      "antennaBeamwidth": 0,
      "antennaDowntilt": 0,
      "antennaGain": 0,
      "antennaGainNewField": "",
      "antennaModel": "",
      "cpeCbsdIndication": false,
      "eirpCapability": 0,
      "eirpCapabilityNewField": "",
      "height": "",
      "heightType": "",
      "horizontalAccuracy": "",
      "indoorDeployment": false,
      "latitude": "",
      "longitude": "",
      "verticalAccuracy": ""
    },
    "isSigned": false,
    "measurementCapabilities": [],
    "model": {
      "firmwareVersion": "",
      "hardwareVersion": "",
      "name": "",
      "softwareVersion": "",
      "vendor": ""
    },
    "state": "",
    "updateTime": "",
    "userId": ""
  },
  "currentChannels": [
    {
      "frequencyRange": {
        "highFrequencyMhz": "",
        "lowFrequencyMhz": ""
      },
      "score": ""
    }
  ],
  "deviceMetadata": {
    "antennaModel": "",
    "commonChannelGroup": "",
    "interferenceCoordinationGroup": "",
    "nrqzValidated": false,
    "nrqzValidation": {
      "caseId": "",
      "cpiId": "",
      "latitude": "",
      "longitude": "",
      "state": ""
    }
  },
  "displayName": "",
  "fccId": "",
  "grantRangeAllowlists": [
    {}
  ],
  "grants": [
    {
      "channelType": "",
      "expireTime": "",
      "frequencyRange": {},
      "grantId": "",
      "lastHeartbeatTransmitExpireTime": "",
      "maxEirp": "",
      "moveList": [
        {
          "dpaId": "",
          "frequencyRange": {}
        }
      ],
      "state": "",
      "suspensionReason": []
    }
  ],
  "name": "",
  "preloadedConfig": {},
  "serialNumber": "",
  "state": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/devices")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/devices"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\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  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/devices")
  .header("content-type", "application/json")
  .body("{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  activeConfig: {
    airInterface: {
      radioTechnology: '',
      supportedSpec: ''
    },
    callSign: '',
    category: '',
    installationParams: {
      antennaAzimuth: 0,
      antennaBeamwidth: 0,
      antennaDowntilt: 0,
      antennaGain: 0,
      antennaGainNewField: '',
      antennaModel: '',
      cpeCbsdIndication: false,
      eirpCapability: 0,
      eirpCapabilityNewField: '',
      height: '',
      heightType: '',
      horizontalAccuracy: '',
      indoorDeployment: false,
      latitude: '',
      longitude: '',
      verticalAccuracy: ''
    },
    isSigned: false,
    measurementCapabilities: [],
    model: {
      firmwareVersion: '',
      hardwareVersion: '',
      name: '',
      softwareVersion: '',
      vendor: ''
    },
    state: '',
    updateTime: '',
    userId: ''
  },
  currentChannels: [
    {
      frequencyRange: {
        highFrequencyMhz: '',
        lowFrequencyMhz: ''
      },
      score: ''
    }
  ],
  deviceMetadata: {
    antennaModel: '',
    commonChannelGroup: '',
    interferenceCoordinationGroup: '',
    nrqzValidated: false,
    nrqzValidation: {
      caseId: '',
      cpiId: '',
      latitude: '',
      longitude: '',
      state: ''
    }
  },
  displayName: '',
  fccId: '',
  grantRangeAllowlists: [
    {}
  ],
  grants: [
    {
      channelType: '',
      expireTime: '',
      frequencyRange: {},
      grantId: '',
      lastHeartbeatTransmitExpireTime: '',
      maxEirp: '',
      moveList: [
        {
          dpaId: '',
          frequencyRange: {}
        }
      ],
      state: '',
      suspensionReason: []
    }
  ],
  name: '',
  preloadedConfig: {},
  serialNumber: '',
  state: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/devices');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/devices',
  headers: {'content-type': 'application/json'},
  data: {
    activeConfig: {
      airInterface: {radioTechnology: '', supportedSpec: ''},
      callSign: '',
      category: '',
      installationParams: {
        antennaAzimuth: 0,
        antennaBeamwidth: 0,
        antennaDowntilt: 0,
        antennaGain: 0,
        antennaGainNewField: '',
        antennaModel: '',
        cpeCbsdIndication: false,
        eirpCapability: 0,
        eirpCapabilityNewField: '',
        height: '',
        heightType: '',
        horizontalAccuracy: '',
        indoorDeployment: false,
        latitude: '',
        longitude: '',
        verticalAccuracy: ''
      },
      isSigned: false,
      measurementCapabilities: [],
      model: {
        firmwareVersion: '',
        hardwareVersion: '',
        name: '',
        softwareVersion: '',
        vendor: ''
      },
      state: '',
      updateTime: '',
      userId: ''
    },
    currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
    deviceMetadata: {
      antennaModel: '',
      commonChannelGroup: '',
      interferenceCoordinationGroup: '',
      nrqzValidated: false,
      nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
    },
    displayName: '',
    fccId: '',
    grantRangeAllowlists: [{}],
    grants: [
      {
        channelType: '',
        expireTime: '',
        frequencyRange: {},
        grantId: '',
        lastHeartbeatTransmitExpireTime: '',
        maxEirp: '',
        moveList: [{dpaId: '', frequencyRange: {}}],
        state: '',
        suspensionReason: []
      }
    ],
    name: '',
    preloadedConfig: {},
    serialNumber: '',
    state: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"activeConfig":{"airInterface":{"radioTechnology":"","supportedSpec":""},"callSign":"","category":"","installationParams":{"antennaAzimuth":0,"antennaBeamwidth":0,"antennaDowntilt":0,"antennaGain":0,"antennaGainNewField":"","antennaModel":"","cpeCbsdIndication":false,"eirpCapability":0,"eirpCapabilityNewField":"","height":"","heightType":"","horizontalAccuracy":"","indoorDeployment":false,"latitude":"","longitude":"","verticalAccuracy":""},"isSigned":false,"measurementCapabilities":[],"model":{"firmwareVersion":"","hardwareVersion":"","name":"","softwareVersion":"","vendor":""},"state":"","updateTime":"","userId":""},"currentChannels":[{"frequencyRange":{"highFrequencyMhz":"","lowFrequencyMhz":""},"score":""}],"deviceMetadata":{"antennaModel":"","commonChannelGroup":"","interferenceCoordinationGroup":"","nrqzValidated":false,"nrqzValidation":{"caseId":"","cpiId":"","latitude":"","longitude":"","state":""}},"displayName":"","fccId":"","grantRangeAllowlists":[{}],"grants":[{"channelType":"","expireTime":"","frequencyRange":{},"grantId":"","lastHeartbeatTransmitExpireTime":"","maxEirp":"","moveList":[{"dpaId":"","frequencyRange":{}}],"state":"","suspensionReason":[]}],"name":"","preloadedConfig":{},"serialNumber":"","state":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:parent/devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "activeConfig": {\n    "airInterface": {\n      "radioTechnology": "",\n      "supportedSpec": ""\n    },\n    "callSign": "",\n    "category": "",\n    "installationParams": {\n      "antennaAzimuth": 0,\n      "antennaBeamwidth": 0,\n      "antennaDowntilt": 0,\n      "antennaGain": 0,\n      "antennaGainNewField": "",\n      "antennaModel": "",\n      "cpeCbsdIndication": false,\n      "eirpCapability": 0,\n      "eirpCapabilityNewField": "",\n      "height": "",\n      "heightType": "",\n      "horizontalAccuracy": "",\n      "indoorDeployment": false,\n      "latitude": "",\n      "longitude": "",\n      "verticalAccuracy": ""\n    },\n    "isSigned": false,\n    "measurementCapabilities": [],\n    "model": {\n      "firmwareVersion": "",\n      "hardwareVersion": "",\n      "name": "",\n      "softwareVersion": "",\n      "vendor": ""\n    },\n    "state": "",\n    "updateTime": "",\n    "userId": ""\n  },\n  "currentChannels": [\n    {\n      "frequencyRange": {\n        "highFrequencyMhz": "",\n        "lowFrequencyMhz": ""\n      },\n      "score": ""\n    }\n  ],\n  "deviceMetadata": {\n    "antennaModel": "",\n    "commonChannelGroup": "",\n    "interferenceCoordinationGroup": "",\n    "nrqzValidated": false,\n    "nrqzValidation": {\n      "caseId": "",\n      "cpiId": "",\n      "latitude": "",\n      "longitude": "",\n      "state": ""\n    }\n  },\n  "displayName": "",\n  "fccId": "",\n  "grantRangeAllowlists": [\n    {}\n  ],\n  "grants": [\n    {\n      "channelType": "",\n      "expireTime": "",\n      "frequencyRange": {},\n      "grantId": "",\n      "lastHeartbeatTransmitExpireTime": "",\n      "maxEirp": "",\n      "moveList": [\n        {\n          "dpaId": "",\n          "frequencyRange": {}\n        }\n      ],\n      "state": "",\n      "suspensionReason": []\n    }\n  ],\n  "name": "",\n  "preloadedConfig": {},\n  "serialNumber": "",\n  "state": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/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/v1alpha1/:parent/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({
  activeConfig: {
    airInterface: {radioTechnology: '', supportedSpec: ''},
    callSign: '',
    category: '',
    installationParams: {
      antennaAzimuth: 0,
      antennaBeamwidth: 0,
      antennaDowntilt: 0,
      antennaGain: 0,
      antennaGainNewField: '',
      antennaModel: '',
      cpeCbsdIndication: false,
      eirpCapability: 0,
      eirpCapabilityNewField: '',
      height: '',
      heightType: '',
      horizontalAccuracy: '',
      indoorDeployment: false,
      latitude: '',
      longitude: '',
      verticalAccuracy: ''
    },
    isSigned: false,
    measurementCapabilities: [],
    model: {
      firmwareVersion: '',
      hardwareVersion: '',
      name: '',
      softwareVersion: '',
      vendor: ''
    },
    state: '',
    updateTime: '',
    userId: ''
  },
  currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
  deviceMetadata: {
    antennaModel: '',
    commonChannelGroup: '',
    interferenceCoordinationGroup: '',
    nrqzValidated: false,
    nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
  },
  displayName: '',
  fccId: '',
  grantRangeAllowlists: [{}],
  grants: [
    {
      channelType: '',
      expireTime: '',
      frequencyRange: {},
      grantId: '',
      lastHeartbeatTransmitExpireTime: '',
      maxEirp: '',
      moveList: [{dpaId: '', frequencyRange: {}}],
      state: '',
      suspensionReason: []
    }
  ],
  name: '',
  preloadedConfig: {},
  serialNumber: '',
  state: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/devices',
  headers: {'content-type': 'application/json'},
  body: {
    activeConfig: {
      airInterface: {radioTechnology: '', supportedSpec: ''},
      callSign: '',
      category: '',
      installationParams: {
        antennaAzimuth: 0,
        antennaBeamwidth: 0,
        antennaDowntilt: 0,
        antennaGain: 0,
        antennaGainNewField: '',
        antennaModel: '',
        cpeCbsdIndication: false,
        eirpCapability: 0,
        eirpCapabilityNewField: '',
        height: '',
        heightType: '',
        horizontalAccuracy: '',
        indoorDeployment: false,
        latitude: '',
        longitude: '',
        verticalAccuracy: ''
      },
      isSigned: false,
      measurementCapabilities: [],
      model: {
        firmwareVersion: '',
        hardwareVersion: '',
        name: '',
        softwareVersion: '',
        vendor: ''
      },
      state: '',
      updateTime: '',
      userId: ''
    },
    currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
    deviceMetadata: {
      antennaModel: '',
      commonChannelGroup: '',
      interferenceCoordinationGroup: '',
      nrqzValidated: false,
      nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
    },
    displayName: '',
    fccId: '',
    grantRangeAllowlists: [{}],
    grants: [
      {
        channelType: '',
        expireTime: '',
        frequencyRange: {},
        grantId: '',
        lastHeartbeatTransmitExpireTime: '',
        maxEirp: '',
        moveList: [{dpaId: '', frequencyRange: {}}],
        state: '',
        suspensionReason: []
      }
    ],
    name: '',
    preloadedConfig: {},
    serialNumber: '',
    state: ''
  },
  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}}/v1alpha1/:parent/devices');

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

req.type('json');
req.send({
  activeConfig: {
    airInterface: {
      radioTechnology: '',
      supportedSpec: ''
    },
    callSign: '',
    category: '',
    installationParams: {
      antennaAzimuth: 0,
      antennaBeamwidth: 0,
      antennaDowntilt: 0,
      antennaGain: 0,
      antennaGainNewField: '',
      antennaModel: '',
      cpeCbsdIndication: false,
      eirpCapability: 0,
      eirpCapabilityNewField: '',
      height: '',
      heightType: '',
      horizontalAccuracy: '',
      indoorDeployment: false,
      latitude: '',
      longitude: '',
      verticalAccuracy: ''
    },
    isSigned: false,
    measurementCapabilities: [],
    model: {
      firmwareVersion: '',
      hardwareVersion: '',
      name: '',
      softwareVersion: '',
      vendor: ''
    },
    state: '',
    updateTime: '',
    userId: ''
  },
  currentChannels: [
    {
      frequencyRange: {
        highFrequencyMhz: '',
        lowFrequencyMhz: ''
      },
      score: ''
    }
  ],
  deviceMetadata: {
    antennaModel: '',
    commonChannelGroup: '',
    interferenceCoordinationGroup: '',
    nrqzValidated: false,
    nrqzValidation: {
      caseId: '',
      cpiId: '',
      latitude: '',
      longitude: '',
      state: ''
    }
  },
  displayName: '',
  fccId: '',
  grantRangeAllowlists: [
    {}
  ],
  grants: [
    {
      channelType: '',
      expireTime: '',
      frequencyRange: {},
      grantId: '',
      lastHeartbeatTransmitExpireTime: '',
      maxEirp: '',
      moveList: [
        {
          dpaId: '',
          frequencyRange: {}
        }
      ],
      state: '',
      suspensionReason: []
    }
  ],
  name: '',
  preloadedConfig: {},
  serialNumber: '',
  state: ''
});

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}}/v1alpha1/:parent/devices',
  headers: {'content-type': 'application/json'},
  data: {
    activeConfig: {
      airInterface: {radioTechnology: '', supportedSpec: ''},
      callSign: '',
      category: '',
      installationParams: {
        antennaAzimuth: 0,
        antennaBeamwidth: 0,
        antennaDowntilt: 0,
        antennaGain: 0,
        antennaGainNewField: '',
        antennaModel: '',
        cpeCbsdIndication: false,
        eirpCapability: 0,
        eirpCapabilityNewField: '',
        height: '',
        heightType: '',
        horizontalAccuracy: '',
        indoorDeployment: false,
        latitude: '',
        longitude: '',
        verticalAccuracy: ''
      },
      isSigned: false,
      measurementCapabilities: [],
      model: {
        firmwareVersion: '',
        hardwareVersion: '',
        name: '',
        softwareVersion: '',
        vendor: ''
      },
      state: '',
      updateTime: '',
      userId: ''
    },
    currentChannels: [{frequencyRange: {highFrequencyMhz: '', lowFrequencyMhz: ''}, score: ''}],
    deviceMetadata: {
      antennaModel: '',
      commonChannelGroup: '',
      interferenceCoordinationGroup: '',
      nrqzValidated: false,
      nrqzValidation: {caseId: '', cpiId: '', latitude: '', longitude: '', state: ''}
    },
    displayName: '',
    fccId: '',
    grantRangeAllowlists: [{}],
    grants: [
      {
        channelType: '',
        expireTime: '',
        frequencyRange: {},
        grantId: '',
        lastHeartbeatTransmitExpireTime: '',
        maxEirp: '',
        moveList: [{dpaId: '', frequencyRange: {}}],
        state: '',
        suspensionReason: []
      }
    ],
    name: '',
    preloadedConfig: {},
    serialNumber: '',
    state: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"activeConfig":{"airInterface":{"radioTechnology":"","supportedSpec":""},"callSign":"","category":"","installationParams":{"antennaAzimuth":0,"antennaBeamwidth":0,"antennaDowntilt":0,"antennaGain":0,"antennaGainNewField":"","antennaModel":"","cpeCbsdIndication":false,"eirpCapability":0,"eirpCapabilityNewField":"","height":"","heightType":"","horizontalAccuracy":"","indoorDeployment":false,"latitude":"","longitude":"","verticalAccuracy":""},"isSigned":false,"measurementCapabilities":[],"model":{"firmwareVersion":"","hardwareVersion":"","name":"","softwareVersion":"","vendor":""},"state":"","updateTime":"","userId":""},"currentChannels":[{"frequencyRange":{"highFrequencyMhz":"","lowFrequencyMhz":""},"score":""}],"deviceMetadata":{"antennaModel":"","commonChannelGroup":"","interferenceCoordinationGroup":"","nrqzValidated":false,"nrqzValidation":{"caseId":"","cpiId":"","latitude":"","longitude":"","state":""}},"displayName":"","fccId":"","grantRangeAllowlists":[{}],"grants":[{"channelType":"","expireTime":"","frequencyRange":{},"grantId":"","lastHeartbeatTransmitExpireTime":"","maxEirp":"","moveList":[{"dpaId":"","frequencyRange":{}}],"state":"","suspensionReason":[]}],"name":"","preloadedConfig":{},"serialNumber":"","state":""}'
};

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 = @{ @"activeConfig": @{ @"airInterface": @{ @"radioTechnology": @"", @"supportedSpec": @"" }, @"callSign": @"", @"category": @"", @"installationParams": @{ @"antennaAzimuth": @0, @"antennaBeamwidth": @0, @"antennaDowntilt": @0, @"antennaGain": @0, @"antennaGainNewField": @"", @"antennaModel": @"", @"cpeCbsdIndication": @NO, @"eirpCapability": @0, @"eirpCapabilityNewField": @"", @"height": @"", @"heightType": @"", @"horizontalAccuracy": @"", @"indoorDeployment": @NO, @"latitude": @"", @"longitude": @"", @"verticalAccuracy": @"" }, @"isSigned": @NO, @"measurementCapabilities": @[  ], @"model": @{ @"firmwareVersion": @"", @"hardwareVersion": @"", @"name": @"", @"softwareVersion": @"", @"vendor": @"" }, @"state": @"", @"updateTime": @"", @"userId": @"" },
                              @"currentChannels": @[ @{ @"frequencyRange": @{ @"highFrequencyMhz": @"", @"lowFrequencyMhz": @"" }, @"score": @"" } ],
                              @"deviceMetadata": @{ @"antennaModel": @"", @"commonChannelGroup": @"", @"interferenceCoordinationGroup": @"", @"nrqzValidated": @NO, @"nrqzValidation": @{ @"caseId": @"", @"cpiId": @"", @"latitude": @"", @"longitude": @"", @"state": @"" } },
                              @"displayName": @"",
                              @"fccId": @"",
                              @"grantRangeAllowlists": @[ @{  } ],
                              @"grants": @[ @{ @"channelType": @"", @"expireTime": @"", @"frequencyRange": @{  }, @"grantId": @"", @"lastHeartbeatTransmitExpireTime": @"", @"maxEirp": @"", @"moveList": @[ @{ @"dpaId": @"", @"frequencyRange": @{  } } ], @"state": @"", @"suspensionReason": @[  ] } ],
                              @"name": @"",
                              @"preloadedConfig": @{  },
                              @"serialNumber": @"",
                              @"state": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:parent/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}}/v1alpha1/:parent/devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/:parent/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([
    'activeConfig' => [
        'airInterface' => [
                'radioTechnology' => '',
                'supportedSpec' => ''
        ],
        'callSign' => '',
        'category' => '',
        'installationParams' => [
                'antennaAzimuth' => 0,
                'antennaBeamwidth' => 0,
                'antennaDowntilt' => 0,
                'antennaGain' => 0,
                'antennaGainNewField' => '',
                'antennaModel' => '',
                'cpeCbsdIndication' => null,
                'eirpCapability' => 0,
                'eirpCapabilityNewField' => '',
                'height' => '',
                'heightType' => '',
                'horizontalAccuracy' => '',
                'indoorDeployment' => null,
                'latitude' => '',
                'longitude' => '',
                'verticalAccuracy' => ''
        ],
        'isSigned' => null,
        'measurementCapabilities' => [
                
        ],
        'model' => [
                'firmwareVersion' => '',
                'hardwareVersion' => '',
                'name' => '',
                'softwareVersion' => '',
                'vendor' => ''
        ],
        'state' => '',
        'updateTime' => '',
        'userId' => ''
    ],
    'currentChannels' => [
        [
                'frequencyRange' => [
                                'highFrequencyMhz' => '',
                                'lowFrequencyMhz' => ''
                ],
                'score' => ''
        ]
    ],
    'deviceMetadata' => [
        'antennaModel' => '',
        'commonChannelGroup' => '',
        'interferenceCoordinationGroup' => '',
        'nrqzValidated' => null,
        'nrqzValidation' => [
                'caseId' => '',
                'cpiId' => '',
                'latitude' => '',
                'longitude' => '',
                'state' => ''
        ]
    ],
    'displayName' => '',
    'fccId' => '',
    'grantRangeAllowlists' => [
        [
                
        ]
    ],
    'grants' => [
        [
                'channelType' => '',
                'expireTime' => '',
                'frequencyRange' => [
                                
                ],
                'grantId' => '',
                'lastHeartbeatTransmitExpireTime' => '',
                'maxEirp' => '',
                'moveList' => [
                                [
                                                                'dpaId' => '',
                                                                'frequencyRange' => [
                                                                                                                                
                                                                ]
                                ]
                ],
                'state' => '',
                'suspensionReason' => [
                                
                ]
        ]
    ],
    'name' => '',
    'preloadedConfig' => [
        
    ],
    'serialNumber' => '',
    'state' => ''
  ]),
  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}}/v1alpha1/:parent/devices', [
  'body' => '{
  "activeConfig": {
    "airInterface": {
      "radioTechnology": "",
      "supportedSpec": ""
    },
    "callSign": "",
    "category": "",
    "installationParams": {
      "antennaAzimuth": 0,
      "antennaBeamwidth": 0,
      "antennaDowntilt": 0,
      "antennaGain": 0,
      "antennaGainNewField": "",
      "antennaModel": "",
      "cpeCbsdIndication": false,
      "eirpCapability": 0,
      "eirpCapabilityNewField": "",
      "height": "",
      "heightType": "",
      "horizontalAccuracy": "",
      "indoorDeployment": false,
      "latitude": "",
      "longitude": "",
      "verticalAccuracy": ""
    },
    "isSigned": false,
    "measurementCapabilities": [],
    "model": {
      "firmwareVersion": "",
      "hardwareVersion": "",
      "name": "",
      "softwareVersion": "",
      "vendor": ""
    },
    "state": "",
    "updateTime": "",
    "userId": ""
  },
  "currentChannels": [
    {
      "frequencyRange": {
        "highFrequencyMhz": "",
        "lowFrequencyMhz": ""
      },
      "score": ""
    }
  ],
  "deviceMetadata": {
    "antennaModel": "",
    "commonChannelGroup": "",
    "interferenceCoordinationGroup": "",
    "nrqzValidated": false,
    "nrqzValidation": {
      "caseId": "",
      "cpiId": "",
      "latitude": "",
      "longitude": "",
      "state": ""
    }
  },
  "displayName": "",
  "fccId": "",
  "grantRangeAllowlists": [
    {}
  ],
  "grants": [
    {
      "channelType": "",
      "expireTime": "",
      "frequencyRange": {},
      "grantId": "",
      "lastHeartbeatTransmitExpireTime": "",
      "maxEirp": "",
      "moveList": [
        {
          "dpaId": "",
          "frequencyRange": {}
        }
      ],
      "state": "",
      "suspensionReason": []
    }
  ],
  "name": "",
  "preloadedConfig": {},
  "serialNumber": "",
  "state": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/devices');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'activeConfig' => [
    'airInterface' => [
        'radioTechnology' => '',
        'supportedSpec' => ''
    ],
    'callSign' => '',
    'category' => '',
    'installationParams' => [
        'antennaAzimuth' => 0,
        'antennaBeamwidth' => 0,
        'antennaDowntilt' => 0,
        'antennaGain' => 0,
        'antennaGainNewField' => '',
        'antennaModel' => '',
        'cpeCbsdIndication' => null,
        'eirpCapability' => 0,
        'eirpCapabilityNewField' => '',
        'height' => '',
        'heightType' => '',
        'horizontalAccuracy' => '',
        'indoorDeployment' => null,
        'latitude' => '',
        'longitude' => '',
        'verticalAccuracy' => ''
    ],
    'isSigned' => null,
    'measurementCapabilities' => [
        
    ],
    'model' => [
        'firmwareVersion' => '',
        'hardwareVersion' => '',
        'name' => '',
        'softwareVersion' => '',
        'vendor' => ''
    ],
    'state' => '',
    'updateTime' => '',
    'userId' => ''
  ],
  'currentChannels' => [
    [
        'frequencyRange' => [
                'highFrequencyMhz' => '',
                'lowFrequencyMhz' => ''
        ],
        'score' => ''
    ]
  ],
  'deviceMetadata' => [
    'antennaModel' => '',
    'commonChannelGroup' => '',
    'interferenceCoordinationGroup' => '',
    'nrqzValidated' => null,
    'nrqzValidation' => [
        'caseId' => '',
        'cpiId' => '',
        'latitude' => '',
        'longitude' => '',
        'state' => ''
    ]
  ],
  'displayName' => '',
  'fccId' => '',
  'grantRangeAllowlists' => [
    [
        
    ]
  ],
  'grants' => [
    [
        'channelType' => '',
        'expireTime' => '',
        'frequencyRange' => [
                
        ],
        'grantId' => '',
        'lastHeartbeatTransmitExpireTime' => '',
        'maxEirp' => '',
        'moveList' => [
                [
                                'dpaId' => '',
                                'frequencyRange' => [
                                                                
                                ]
                ]
        ],
        'state' => '',
        'suspensionReason' => [
                
        ]
    ]
  ],
  'name' => '',
  'preloadedConfig' => [
    
  ],
  'serialNumber' => '',
  'state' => ''
]));

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

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

append(json_encode([
  'activeConfig' => [
    'airInterface' => [
        'radioTechnology' => '',
        'supportedSpec' => ''
    ],
    'callSign' => '',
    'category' => '',
    'installationParams' => [
        'antennaAzimuth' => 0,
        'antennaBeamwidth' => 0,
        'antennaDowntilt' => 0,
        'antennaGain' => 0,
        'antennaGainNewField' => '',
        'antennaModel' => '',
        'cpeCbsdIndication' => null,
        'eirpCapability' => 0,
        'eirpCapabilityNewField' => '',
        'height' => '',
        'heightType' => '',
        'horizontalAccuracy' => '',
        'indoorDeployment' => null,
        'latitude' => '',
        'longitude' => '',
        'verticalAccuracy' => ''
    ],
    'isSigned' => null,
    'measurementCapabilities' => [
        
    ],
    'model' => [
        'firmwareVersion' => '',
        'hardwareVersion' => '',
        'name' => '',
        'softwareVersion' => '',
        'vendor' => ''
    ],
    'state' => '',
    'updateTime' => '',
    'userId' => ''
  ],
  'currentChannels' => [
    [
        'frequencyRange' => [
                'highFrequencyMhz' => '',
                'lowFrequencyMhz' => ''
        ],
        'score' => ''
    ]
  ],
  'deviceMetadata' => [
    'antennaModel' => '',
    'commonChannelGroup' => '',
    'interferenceCoordinationGroup' => '',
    'nrqzValidated' => null,
    'nrqzValidation' => [
        'caseId' => '',
        'cpiId' => '',
        'latitude' => '',
        'longitude' => '',
        'state' => ''
    ]
  ],
  'displayName' => '',
  'fccId' => '',
  'grantRangeAllowlists' => [
    [
        
    ]
  ],
  'grants' => [
    [
        'channelType' => '',
        'expireTime' => '',
        'frequencyRange' => [
                
        ],
        'grantId' => '',
        'lastHeartbeatTransmitExpireTime' => '',
        'maxEirp' => '',
        'moveList' => [
                [
                                'dpaId' => '',
                                'frequencyRange' => [
                                                                
                                ]
                ]
        ],
        'state' => '',
        'suspensionReason' => [
                
        ]
    ]
  ],
  'name' => '',
  'preloadedConfig' => [
    
  ],
  'serialNumber' => '',
  'state' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/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}}/v1alpha1/:parent/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "activeConfig": {
    "airInterface": {
      "radioTechnology": "",
      "supportedSpec": ""
    },
    "callSign": "",
    "category": "",
    "installationParams": {
      "antennaAzimuth": 0,
      "antennaBeamwidth": 0,
      "antennaDowntilt": 0,
      "antennaGain": 0,
      "antennaGainNewField": "",
      "antennaModel": "",
      "cpeCbsdIndication": false,
      "eirpCapability": 0,
      "eirpCapabilityNewField": "",
      "height": "",
      "heightType": "",
      "horizontalAccuracy": "",
      "indoorDeployment": false,
      "latitude": "",
      "longitude": "",
      "verticalAccuracy": ""
    },
    "isSigned": false,
    "measurementCapabilities": [],
    "model": {
      "firmwareVersion": "",
      "hardwareVersion": "",
      "name": "",
      "softwareVersion": "",
      "vendor": ""
    },
    "state": "",
    "updateTime": "",
    "userId": ""
  },
  "currentChannels": [
    {
      "frequencyRange": {
        "highFrequencyMhz": "",
        "lowFrequencyMhz": ""
      },
      "score": ""
    }
  ],
  "deviceMetadata": {
    "antennaModel": "",
    "commonChannelGroup": "",
    "interferenceCoordinationGroup": "",
    "nrqzValidated": false,
    "nrqzValidation": {
      "caseId": "",
      "cpiId": "",
      "latitude": "",
      "longitude": "",
      "state": ""
    }
  },
  "displayName": "",
  "fccId": "",
  "grantRangeAllowlists": [
    {}
  ],
  "grants": [
    {
      "channelType": "",
      "expireTime": "",
      "frequencyRange": {},
      "grantId": "",
      "lastHeartbeatTransmitExpireTime": "",
      "maxEirp": "",
      "moveList": [
        {
          "dpaId": "",
          "frequencyRange": {}
        }
      ],
      "state": "",
      "suspensionReason": []
    }
  ],
  "name": "",
  "preloadedConfig": {},
  "serialNumber": "",
  "state": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "activeConfig": {
    "airInterface": {
      "radioTechnology": "",
      "supportedSpec": ""
    },
    "callSign": "",
    "category": "",
    "installationParams": {
      "antennaAzimuth": 0,
      "antennaBeamwidth": 0,
      "antennaDowntilt": 0,
      "antennaGain": 0,
      "antennaGainNewField": "",
      "antennaModel": "",
      "cpeCbsdIndication": false,
      "eirpCapability": 0,
      "eirpCapabilityNewField": "",
      "height": "",
      "heightType": "",
      "horizontalAccuracy": "",
      "indoorDeployment": false,
      "latitude": "",
      "longitude": "",
      "verticalAccuracy": ""
    },
    "isSigned": false,
    "measurementCapabilities": [],
    "model": {
      "firmwareVersion": "",
      "hardwareVersion": "",
      "name": "",
      "softwareVersion": "",
      "vendor": ""
    },
    "state": "",
    "updateTime": "",
    "userId": ""
  },
  "currentChannels": [
    {
      "frequencyRange": {
        "highFrequencyMhz": "",
        "lowFrequencyMhz": ""
      },
      "score": ""
    }
  ],
  "deviceMetadata": {
    "antennaModel": "",
    "commonChannelGroup": "",
    "interferenceCoordinationGroup": "",
    "nrqzValidated": false,
    "nrqzValidation": {
      "caseId": "",
      "cpiId": "",
      "latitude": "",
      "longitude": "",
      "state": ""
    }
  },
  "displayName": "",
  "fccId": "",
  "grantRangeAllowlists": [
    {}
  ],
  "grants": [
    {
      "channelType": "",
      "expireTime": "",
      "frequencyRange": {},
      "grantId": "",
      "lastHeartbeatTransmitExpireTime": "",
      "maxEirp": "",
      "moveList": [
        {
          "dpaId": "",
          "frequencyRange": {}
        }
      ],
      "state": "",
      "suspensionReason": []
    }
  ],
  "name": "",
  "preloadedConfig": {},
  "serialNumber": "",
  "state": ""
}'

import http.client

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

payload = "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/devices", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/devices"

payload = {
    "activeConfig": {
        "airInterface": {
            "radioTechnology": "",
            "supportedSpec": ""
        },
        "callSign": "",
        "category": "",
        "installationParams": {
            "antennaAzimuth": 0,
            "antennaBeamwidth": 0,
            "antennaDowntilt": 0,
            "antennaGain": 0,
            "antennaGainNewField": "",
            "antennaModel": "",
            "cpeCbsdIndication": False,
            "eirpCapability": 0,
            "eirpCapabilityNewField": "",
            "height": "",
            "heightType": "",
            "horizontalAccuracy": "",
            "indoorDeployment": False,
            "latitude": "",
            "longitude": "",
            "verticalAccuracy": ""
        },
        "isSigned": False,
        "measurementCapabilities": [],
        "model": {
            "firmwareVersion": "",
            "hardwareVersion": "",
            "name": "",
            "softwareVersion": "",
            "vendor": ""
        },
        "state": "",
        "updateTime": "",
        "userId": ""
    },
    "currentChannels": [
        {
            "frequencyRange": {
                "highFrequencyMhz": "",
                "lowFrequencyMhz": ""
            },
            "score": ""
        }
    ],
    "deviceMetadata": {
        "antennaModel": "",
        "commonChannelGroup": "",
        "interferenceCoordinationGroup": "",
        "nrqzValidated": False,
        "nrqzValidation": {
            "caseId": "",
            "cpiId": "",
            "latitude": "",
            "longitude": "",
            "state": ""
        }
    },
    "displayName": "",
    "fccId": "",
    "grantRangeAllowlists": [{}],
    "grants": [
        {
            "channelType": "",
            "expireTime": "",
            "frequencyRange": {},
            "grantId": "",
            "lastHeartbeatTransmitExpireTime": "",
            "maxEirp": "",
            "moveList": [
                {
                    "dpaId": "",
                    "frequencyRange": {}
                }
            ],
            "state": "",
            "suspensionReason": []
        }
    ],
    "name": "",
    "preloadedConfig": {},
    "serialNumber": "",
    "state": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/devices"

payload <- "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\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}}/v1alpha1/:parent/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  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\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/v1alpha1/:parent/devices') do |req|
  req.body = "{\n  \"activeConfig\": {\n    \"airInterface\": {\n      \"radioTechnology\": \"\",\n      \"supportedSpec\": \"\"\n    },\n    \"callSign\": \"\",\n    \"category\": \"\",\n    \"installationParams\": {\n      \"antennaAzimuth\": 0,\n      \"antennaBeamwidth\": 0,\n      \"antennaDowntilt\": 0,\n      \"antennaGain\": 0,\n      \"antennaGainNewField\": \"\",\n      \"antennaModel\": \"\",\n      \"cpeCbsdIndication\": false,\n      \"eirpCapability\": 0,\n      \"eirpCapabilityNewField\": \"\",\n      \"height\": \"\",\n      \"heightType\": \"\",\n      \"horizontalAccuracy\": \"\",\n      \"indoorDeployment\": false,\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"verticalAccuracy\": \"\"\n    },\n    \"isSigned\": false,\n    \"measurementCapabilities\": [],\n    \"model\": {\n      \"firmwareVersion\": \"\",\n      \"hardwareVersion\": \"\",\n      \"name\": \"\",\n      \"softwareVersion\": \"\",\n      \"vendor\": \"\"\n    },\n    \"state\": \"\",\n    \"updateTime\": \"\",\n    \"userId\": \"\"\n  },\n  \"currentChannels\": [\n    {\n      \"frequencyRange\": {\n        \"highFrequencyMhz\": \"\",\n        \"lowFrequencyMhz\": \"\"\n      },\n      \"score\": \"\"\n    }\n  ],\n  \"deviceMetadata\": {\n    \"antennaModel\": \"\",\n    \"commonChannelGroup\": \"\",\n    \"interferenceCoordinationGroup\": \"\",\n    \"nrqzValidated\": false,\n    \"nrqzValidation\": {\n      \"caseId\": \"\",\n      \"cpiId\": \"\",\n      \"latitude\": \"\",\n      \"longitude\": \"\",\n      \"state\": \"\"\n    }\n  },\n  \"displayName\": \"\",\n  \"fccId\": \"\",\n  \"grantRangeAllowlists\": [\n    {}\n  ],\n  \"grants\": [\n    {\n      \"channelType\": \"\",\n      \"expireTime\": \"\",\n      \"frequencyRange\": {},\n      \"grantId\": \"\",\n      \"lastHeartbeatTransmitExpireTime\": \"\",\n      \"maxEirp\": \"\",\n      \"moveList\": [\n        {\n          \"dpaId\": \"\",\n          \"frequencyRange\": {}\n        }\n      ],\n      \"state\": \"\",\n      \"suspensionReason\": []\n    }\n  ],\n  \"name\": \"\",\n  \"preloadedConfig\": {},\n  \"serialNumber\": \"\",\n  \"state\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "activeConfig": json!({
            "airInterface": json!({
                "radioTechnology": "",
                "supportedSpec": ""
            }),
            "callSign": "",
            "category": "",
            "installationParams": json!({
                "antennaAzimuth": 0,
                "antennaBeamwidth": 0,
                "antennaDowntilt": 0,
                "antennaGain": 0,
                "antennaGainNewField": "",
                "antennaModel": "",
                "cpeCbsdIndication": false,
                "eirpCapability": 0,
                "eirpCapabilityNewField": "",
                "height": "",
                "heightType": "",
                "horizontalAccuracy": "",
                "indoorDeployment": false,
                "latitude": "",
                "longitude": "",
                "verticalAccuracy": ""
            }),
            "isSigned": false,
            "measurementCapabilities": (),
            "model": json!({
                "firmwareVersion": "",
                "hardwareVersion": "",
                "name": "",
                "softwareVersion": "",
                "vendor": ""
            }),
            "state": "",
            "updateTime": "",
            "userId": ""
        }),
        "currentChannels": (
            json!({
                "frequencyRange": json!({
                    "highFrequencyMhz": "",
                    "lowFrequencyMhz": ""
                }),
                "score": ""
            })
        ),
        "deviceMetadata": json!({
            "antennaModel": "",
            "commonChannelGroup": "",
            "interferenceCoordinationGroup": "",
            "nrqzValidated": false,
            "nrqzValidation": json!({
                "caseId": "",
                "cpiId": "",
                "latitude": "",
                "longitude": "",
                "state": ""
            })
        }),
        "displayName": "",
        "fccId": "",
        "grantRangeAllowlists": (json!({})),
        "grants": (
            json!({
                "channelType": "",
                "expireTime": "",
                "frequencyRange": json!({}),
                "grantId": "",
                "lastHeartbeatTransmitExpireTime": "",
                "maxEirp": "",
                "moveList": (
                    json!({
                        "dpaId": "",
                        "frequencyRange": json!({})
                    })
                ),
                "state": "",
                "suspensionReason": ()
            })
        ),
        "name": "",
        "preloadedConfig": json!({}),
        "serialNumber": "",
        "state": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "activeConfig": {
    "airInterface": {
      "radioTechnology": "",
      "supportedSpec": ""
    },
    "callSign": "",
    "category": "",
    "installationParams": {
      "antennaAzimuth": 0,
      "antennaBeamwidth": 0,
      "antennaDowntilt": 0,
      "antennaGain": 0,
      "antennaGainNewField": "",
      "antennaModel": "",
      "cpeCbsdIndication": false,
      "eirpCapability": 0,
      "eirpCapabilityNewField": "",
      "height": "",
      "heightType": "",
      "horizontalAccuracy": "",
      "indoorDeployment": false,
      "latitude": "",
      "longitude": "",
      "verticalAccuracy": ""
    },
    "isSigned": false,
    "measurementCapabilities": [],
    "model": {
      "firmwareVersion": "",
      "hardwareVersion": "",
      "name": "",
      "softwareVersion": "",
      "vendor": ""
    },
    "state": "",
    "updateTime": "",
    "userId": ""
  },
  "currentChannels": [
    {
      "frequencyRange": {
        "highFrequencyMhz": "",
        "lowFrequencyMhz": ""
      },
      "score": ""
    }
  ],
  "deviceMetadata": {
    "antennaModel": "",
    "commonChannelGroup": "",
    "interferenceCoordinationGroup": "",
    "nrqzValidated": false,
    "nrqzValidation": {
      "caseId": "",
      "cpiId": "",
      "latitude": "",
      "longitude": "",
      "state": ""
    }
  },
  "displayName": "",
  "fccId": "",
  "grantRangeAllowlists": [
    {}
  ],
  "grants": [
    {
      "channelType": "",
      "expireTime": "",
      "frequencyRange": {},
      "grantId": "",
      "lastHeartbeatTransmitExpireTime": "",
      "maxEirp": "",
      "moveList": [
        {
          "dpaId": "",
          "frequencyRange": {}
        }
      ],
      "state": "",
      "suspensionReason": []
    }
  ],
  "name": "",
  "preloadedConfig": {},
  "serialNumber": "",
  "state": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/devices \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "activeConfig": {\n    "airInterface": {\n      "radioTechnology": "",\n      "supportedSpec": ""\n    },\n    "callSign": "",\n    "category": "",\n    "installationParams": {\n      "antennaAzimuth": 0,\n      "antennaBeamwidth": 0,\n      "antennaDowntilt": 0,\n      "antennaGain": 0,\n      "antennaGainNewField": "",\n      "antennaModel": "",\n      "cpeCbsdIndication": false,\n      "eirpCapability": 0,\n      "eirpCapabilityNewField": "",\n      "height": "",\n      "heightType": "",\n      "horizontalAccuracy": "",\n      "indoorDeployment": false,\n      "latitude": "",\n      "longitude": "",\n      "verticalAccuracy": ""\n    },\n    "isSigned": false,\n    "measurementCapabilities": [],\n    "model": {\n      "firmwareVersion": "",\n      "hardwareVersion": "",\n      "name": "",\n      "softwareVersion": "",\n      "vendor": ""\n    },\n    "state": "",\n    "updateTime": "",\n    "userId": ""\n  },\n  "currentChannels": [\n    {\n      "frequencyRange": {\n        "highFrequencyMhz": "",\n        "lowFrequencyMhz": ""\n      },\n      "score": ""\n    }\n  ],\n  "deviceMetadata": {\n    "antennaModel": "",\n    "commonChannelGroup": "",\n    "interferenceCoordinationGroup": "",\n    "nrqzValidated": false,\n    "nrqzValidation": {\n      "caseId": "",\n      "cpiId": "",\n      "latitude": "",\n      "longitude": "",\n      "state": ""\n    }\n  },\n  "displayName": "",\n  "fccId": "",\n  "grantRangeAllowlists": [\n    {}\n  ],\n  "grants": [\n    {\n      "channelType": "",\n      "expireTime": "",\n      "frequencyRange": {},\n      "grantId": "",\n      "lastHeartbeatTransmitExpireTime": "",\n      "maxEirp": "",\n      "moveList": [\n        {\n          "dpaId": "",\n          "frequencyRange": {}\n        }\n      ],\n      "state": "",\n      "suspensionReason": []\n    }\n  ],\n  "name": "",\n  "preloadedConfig": {},\n  "serialNumber": "",\n  "state": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/devices

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "activeConfig": [
    "airInterface": [
      "radioTechnology": "",
      "supportedSpec": ""
    ],
    "callSign": "",
    "category": "",
    "installationParams": [
      "antennaAzimuth": 0,
      "antennaBeamwidth": 0,
      "antennaDowntilt": 0,
      "antennaGain": 0,
      "antennaGainNewField": "",
      "antennaModel": "",
      "cpeCbsdIndication": false,
      "eirpCapability": 0,
      "eirpCapabilityNewField": "",
      "height": "",
      "heightType": "",
      "horizontalAccuracy": "",
      "indoorDeployment": false,
      "latitude": "",
      "longitude": "",
      "verticalAccuracy": ""
    ],
    "isSigned": false,
    "measurementCapabilities": [],
    "model": [
      "firmwareVersion": "",
      "hardwareVersion": "",
      "name": "",
      "softwareVersion": "",
      "vendor": ""
    ],
    "state": "",
    "updateTime": "",
    "userId": ""
  ],
  "currentChannels": [
    [
      "frequencyRange": [
        "highFrequencyMhz": "",
        "lowFrequencyMhz": ""
      ],
      "score": ""
    ]
  ],
  "deviceMetadata": [
    "antennaModel": "",
    "commonChannelGroup": "",
    "interferenceCoordinationGroup": "",
    "nrqzValidated": false,
    "nrqzValidation": [
      "caseId": "",
      "cpiId": "",
      "latitude": "",
      "longitude": "",
      "state": ""
    ]
  ],
  "displayName": "",
  "fccId": "",
  "grantRangeAllowlists": [[]],
  "grants": [
    [
      "channelType": "",
      "expireTime": "",
      "frequencyRange": [],
      "grantId": "",
      "lastHeartbeatTransmitExpireTime": "",
      "maxEirp": "",
      "moveList": [
        [
          "dpaId": "",
          "frequencyRange": []
        ]
      ],
      "state": "",
      "suspensionReason": []
    ]
  ],
  "name": "",
  "preloadedConfig": [],
  "serialNumber": "",
  "state": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/devices:createSigned");

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  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/devices:createSigned" {:content-type :json
                                                                                  :form-params {:encodedDevice ""
                                                                                                :installerId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/devices:createSigned"

	payload := strings.NewReader("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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/v1alpha1/:parent/devices:createSigned HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "encodedDevice": "",
  "installerId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/devices:createSigned")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/devices:createSigned"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/devices:createSigned")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/devices:createSigned")
  .header("content-type", "application/json")
  .body("{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  encodedDevice: '',
  installerId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/devices:createSigned');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/devices:createSigned',
  headers: {'content-type': 'application/json'},
  data: {encodedDevice: '', installerId: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/devices:createSigned';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encodedDevice":"","installerId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:parent/devices:createSigned',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "encodedDevice": "",\n  "installerId": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/devices:createSigned',
  headers: {'content-type': 'application/json'},
  body: {encodedDevice: '', installerId: ''},
  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}}/v1alpha1/:parent/devices:createSigned');

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

req.type('json');
req.send({
  encodedDevice: '',
  installerId: ''
});

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}}/v1alpha1/:parent/devices:createSigned',
  headers: {'content-type': 'application/json'},
  data: {encodedDevice: '', installerId: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/devices:createSigned';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encodedDevice":"","installerId":""}'
};

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 = @{ @"encodedDevice": @"",
                              @"installerId": @"" };

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

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

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

 "{{baseUrl}}/v1alpha1/:parent/devices:createSigned",
  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([
    'encodedDevice' => '',
    'installerId' => ''
  ]),
  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}}/v1alpha1/:parent/devices:createSigned', [
  'body' => '{
  "encodedDevice": "",
  "installerId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/devices:createSigned');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'encodedDevice' => '',
  'installerId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/devices:createSigned');
$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}}/v1alpha1/:parent/devices:createSigned' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encodedDevice": "",
  "installerId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/devices:createSigned' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encodedDevice": "",
  "installerId": ""
}'

import http.client

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

payload = "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/devices:createSigned", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/devices:createSigned"

payload = {
    "encodedDevice": "",
    "installerId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/devices:createSigned"

payload <- "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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}}/v1alpha1/:parent/devices:createSigned")

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  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\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/v1alpha1/:parent/devices:createSigned') do |req|
  req.body = "{\n  \"encodedDevice\": \"\",\n  \"installerId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "encodedDevice": "",
        "installerId": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "encodedDevice": "",
  "installerId": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/devices:createSigned \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "encodedDevice": "",\n  "installerId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/devices:createSigned

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/devices");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/devices")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:parent/devices'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/devices")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/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}}/v1alpha1/:parent/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}}/v1alpha1/:parent/devices" in

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

 "{{baseUrl}}/v1alpha1/:parent/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}}/v1alpha1/:parent/devices');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/devices');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/devices' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/devices' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/devices")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/devices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/devices"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/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/v1alpha1/:parent/devices') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/devices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/devices

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:name")

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/v1alpha1/: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}}/v1alpha1/: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}}/v1alpha1/:name" in

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

 "{{baseUrl}}/v1alpha1/: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}}/v1alpha1/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:name")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/: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/v1alpha1/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:name:move");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:name:move" {:content-type :json
                                                                :form-params {:destination ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name:move"

	payload := strings.NewReader("{\n  \"destination\": \"\"\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/v1alpha1/:name:move HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "destination": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name:move"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\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  \"destination\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:move")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:name:move")
  .header("content-type", "application/json")
  .body("{\n  \"destination\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:name:move');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:move',
  headers: {'content-type': 'application/json'},
  data: {destination: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/:name:move';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/v1alpha1/:name:move',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"destination\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name:move")
  .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/v1alpha1/:name:move',
  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({destination: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:move',
  headers: {'content-type': 'application/json'},
  body: {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('POST', '{{baseUrl}}/v1alpha1/:name:move');

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

req.type('json');
req.send({
  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: 'POST',
  url: '{{baseUrl}}/v1alpha1/:name:move',
  headers: {'content-type': 'application/json'},
  data: {destination: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name:move';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"destination": @"" };

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

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

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

 "{{baseUrl}}/v1alpha1/:name:move",
  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([
    '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('POST', '{{baseUrl}}/v1alpha1/:name:move', [
  'body' => '{
  "destination": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name:move');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'destination' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:name:move');
$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}}/v1alpha1/:name:move' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destination": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name:move' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destination": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/v1alpha1/:name:move", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name:move"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name:move"

payload <- "{\n  \"destination\": \"\"\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}}/v1alpha1/:name:move")

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  \"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.post('/baseUrl/v1alpha1/:name:move') do |req|
  req.body = "{\n  \"destination\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "destination": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/:name:move \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "destination": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name:move

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/nodes");

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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/:parent/nodes" {:content-type :json
                                                                   :form-params {:displayName ""
                                                                                 :name ""
                                                                                 :sasUserIds []}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/nodes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:parent/nodes"),
    Content = new StringContent("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:parent/nodes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/nodes"

	payload := strings.NewReader("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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/v1alpha1/:parent/nodes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/:parent/nodes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:parent/nodes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/nodes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/:parent/nodes")
  .header("content-type", "application/json")
  .body("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
  .asString();

const data = JSON.stringify({
  displayName: '',
  name: '',
  sasUserIds: []
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/:parent/nodes');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/nodes',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', name: '', sasUserIds: []}
};

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

const url = '{{baseUrl}}/v1alpha1/:parent/nodes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","name":"","sasUserIds":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:parent/nodes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "displayName": "",\n  "name": "",\n  "sasUserIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/nodes")
  .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/v1alpha1/:parent/nodes',
  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({displayName: '', name: '', sasUserIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/:parent/nodes',
  headers: {'content-type': 'application/json'},
  body: {displayName: '', name: '', sasUserIds: []},
  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}}/v1alpha1/:parent/nodes');

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

req.type('json');
req.send({
  displayName: '',
  name: '',
  sasUserIds: []
});

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}}/v1alpha1/:parent/nodes',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', name: '', sasUserIds: []}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/nodes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","name":"","sasUserIds":[]}'
};

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 = @{ @"displayName": @"",
                              @"name": @"",
                              @"sasUserIds": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/:parent/nodes"]
                                                       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}}/v1alpha1/:parent/nodes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}" in

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

 "{{baseUrl}}/v1alpha1/:parent/nodes",
  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([
    'displayName' => '',
    'name' => '',
    'sasUserIds' => [
        
    ]
  ]),
  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}}/v1alpha1/:parent/nodes', [
  'body' => '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/nodes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'displayName' => '',
  'name' => '',
  'sasUserIds' => [
    
  ]
]));

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

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

append(json_encode([
  'displayName' => '',
  'name' => '',
  'sasUserIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/:parent/nodes');
$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}}/v1alpha1/:parent/nodes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/nodes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}'

import http.client

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

payload = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/:parent/nodes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/nodes"

payload = {
    "displayName": "",
    "name": "",
    "sasUserIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/nodes"

payload <- "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:parent/nodes")

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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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/v1alpha1/:parent/nodes') do |req|
  req.body = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "displayName": "",
        "name": "",
        "sasUserIds": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}' |  \
  http POST {{baseUrl}}/v1alpha1/:parent/nodes \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "displayName": "",\n  "name": "",\n  "sasUserIds": []\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/nodes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "displayName": "",
  "name": "",
  "sasUserIds": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/:parent/nodes");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1alpha1/:parent/nodes")

require "http/client"

url = "{{baseUrl}}/v1alpha1/:parent/nodes"

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

var client = new RestClient("{{baseUrl}}/v1alpha1/:parent/nodes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:parent/nodes"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1alpha1/:parent/nodes'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:parent/nodes")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1alpha1/:parent/nodes');

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}}/v1alpha1/:parent/nodes'};

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

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

const url = '{{baseUrl}}/v1alpha1/:parent/nodes';
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}}/v1alpha1/:parent/nodes"]
                                                       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}}/v1alpha1/:parent/nodes" in

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

 "{{baseUrl}}/v1alpha1/:parent/nodes",
  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}}/v1alpha1/:parent/nodes');

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:parent/nodes');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1alpha1/:parent/nodes' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:parent/nodes' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1alpha1/:parent/nodes")

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:parent/nodes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:parent/nodes"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1alpha1/:parent/nodes")

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/v1alpha1/:parent/nodes') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1alpha1/:parent/nodes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1alpha1/:parent/nodes

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/: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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1alpha1/:name" {:content-type :json
                                                            :form-params {:displayName ""
                                                                          :name ""
                                                                          :sasUserIds []}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:name"),
    Content = new StringContent("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/:name"

	payload := strings.NewReader("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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/v1alpha1/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1alpha1/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/:name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1alpha1/:name")
  .header("content-type", "application/json")
  .body("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
  .asString();

const data = JSON.stringify({
  displayName: '',
  name: '',
  sasUserIds: []
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1alpha1/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', name: '', sasUserIds: []}
};

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

const url = '{{baseUrl}}/v1alpha1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","name":"","sasUserIds":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/:name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "displayName": "",\n  "name": "",\n  "sasUserIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/: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/v1alpha1/: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({displayName: '', name: '', sasUserIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1alpha1/:name',
  headers: {'content-type': 'application/json'},
  body: {displayName: '', name: '', sasUserIds: []},
  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}}/v1alpha1/:name');

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

req.type('json');
req.send({
  displayName: '',
  name: '',
  sasUserIds: []
});

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}}/v1alpha1/:name',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', name: '', sasUserIds: []}
};

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

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

const url = '{{baseUrl}}/v1alpha1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","name":"","sasUserIds":[]}'
};

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 = @{ @"displayName": @"",
                              @"name": @"",
                              @"sasUserIds": @[  ] };

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

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

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

 "{{baseUrl}}/v1alpha1/: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([
    'displayName' => '',
    'name' => '',
    'sasUserIds' => [
        
    ]
  ]),
  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}}/v1alpha1/:name', [
  'body' => '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/:name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'displayName' => '',
  'name' => '',
  'sasUserIds' => [
    
  ]
]));

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

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

append(json_encode([
  'displayName' => '',
  'name' => '',
  'sasUserIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/: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}}/v1alpha1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}'

import http.client

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

payload = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\n}"

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

conn.request("PATCH", "/baseUrl/v1alpha1/:name", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/:name"

payload = {
    "displayName": "",
    "name": "",
    "sasUserIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/:name"

payload <- "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/: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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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/v1alpha1/:name') do |req|
  req.body = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"sasUserIds\": []\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}}/v1alpha1/:name";

    let payload = json!({
        "displayName": "",
        "name": "",
        "sasUserIds": ()
    });

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

echo '{
  "displayName": "",
  "name": "",
  "sasUserIds": []
}' |  \
  http PATCH {{baseUrl}}/v1alpha1/:name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "displayName": "",\n  "name": "",\n  "sasUserIds": []\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "displayName": "",
  "name": "",
  "sasUserIds": []
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/policies:get");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/policies:get" {:content-type :json
                                                                  :form-params {:resource ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/policies:get"

	payload := strings.NewReader("{\n  \"resource\": \"\"\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/v1alpha1/policies:get HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "resource": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/policies:get")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resource\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/policies:get"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resource\": \"\"\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  \"resource\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/policies:get")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/policies:get")
  .header("content-type", "application/json")
  .body("{\n  \"resource\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/policies:get');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/policies:get',
  headers: {'content-type': 'application/json'},
  data: {resource: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/policies:get';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resource":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/policies:get',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resource": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/policies:get',
  headers: {'content-type': 'application/json'},
  body: {resource: ''},
  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}}/v1alpha1/policies:get');

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

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

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}}/v1alpha1/policies:get',
  headers: {'content-type': 'application/json'},
  data: {resource: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/policies:get';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resource":""}'
};

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

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

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

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

 "{{baseUrl}}/v1alpha1/policies:get",
  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([
    'resource' => ''
  ]),
  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}}/v1alpha1/policies:get', [
  'body' => '{
  "resource": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/policies:get');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'resource' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/policies:get');
$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}}/v1alpha1/policies:get' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resource": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/policies:get' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resource": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/v1alpha1/policies:get", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/policies:get"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/policies:get"

payload <- "{\n  \"resource\": \"\"\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}}/v1alpha1/policies:get")

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  \"resource\": \"\"\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/v1alpha1/policies:get') do |req|
  req.body = "{\n  \"resource\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "resource": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/policies:get \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resource": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/policies:get

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/policies:set");

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  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/policies:set" {:content-type :json
                                                                  :form-params {:disableNotification false
                                                                                :policy {:assignments [{:members []
                                                                                                        :role ""}]
                                                                                         :etag ""}
                                                                                :resource ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/policies:set"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\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}}/v1alpha1/policies:set"),
    Content = new StringContent("{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\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}}/v1alpha1/policies:set");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/policies:set"

	payload := strings.NewReader("{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\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/v1alpha1/policies:set HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 172

{
  "disableNotification": false,
  "policy": {
    "assignments": [
      {
        "members": [],
        "role": ""
      }
    ],
    "etag": ""
  },
  "resource": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/policies:set")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1alpha1/policies:set"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\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  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1alpha1/policies:set")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/policies:set")
  .header("content-type", "application/json")
  .body("{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  disableNotification: false,
  policy: {
    assignments: [
      {
        members: [],
        role: ''
      }
    ],
    etag: ''
  },
  resource: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/policies:set');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/policies:set',
  headers: {'content-type': 'application/json'},
  data: {
    disableNotification: false,
    policy: {assignments: [{members: [], role: ''}], etag: ''},
    resource: ''
  }
};

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

const url = '{{baseUrl}}/v1alpha1/policies:set';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"disableNotification":false,"policy":{"assignments":[{"members":[],"role":""}],"etag":""},"resource":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/policies:set',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "disableNotification": false,\n  "policy": {\n    "assignments": [\n      {\n        "members": [],\n        "role": ""\n      }\n    ],\n    "etag": ""\n  },\n  "resource": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/policies:set")
  .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/v1alpha1/policies:set',
  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({
  disableNotification: false,
  policy: {assignments: [{members: [], role: ''}], etag: ''},
  resource: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/policies:set',
  headers: {'content-type': 'application/json'},
  body: {
    disableNotification: false,
    policy: {assignments: [{members: [], role: ''}], etag: ''},
    resource: ''
  },
  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}}/v1alpha1/policies:set');

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

req.type('json');
req.send({
  disableNotification: false,
  policy: {
    assignments: [
      {
        members: [],
        role: ''
      }
    ],
    etag: ''
  },
  resource: ''
});

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}}/v1alpha1/policies:set',
  headers: {'content-type': 'application/json'},
  data: {
    disableNotification: false,
    policy: {assignments: [{members: [], role: ''}], etag: ''},
    resource: ''
  }
};

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

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

const url = '{{baseUrl}}/v1alpha1/policies:set';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"disableNotification":false,"policy":{"assignments":[{"members":[],"role":""}],"etag":""},"resource":""}'
};

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 = @{ @"disableNotification": @NO,
                              @"policy": @{ @"assignments": @[ @{ @"members": @[  ], @"role": @"" } ], @"etag": @"" },
                              @"resource": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/policies:set"]
                                                       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}}/v1alpha1/policies:set" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/policies:set",
  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([
    'disableNotification' => null,
    'policy' => [
        'assignments' => [
                [
                                'members' => [
                                                                
                                ],
                                'role' => ''
                ]
        ],
        'etag' => ''
    ],
    'resource' => ''
  ]),
  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}}/v1alpha1/policies:set', [
  'body' => '{
  "disableNotification": false,
  "policy": {
    "assignments": [
      {
        "members": [],
        "role": ""
      }
    ],
    "etag": ""
  },
  "resource": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/policies:set');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'disableNotification' => null,
  'policy' => [
    'assignments' => [
        [
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => ''
  ],
  'resource' => ''
]));

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

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

append(json_encode([
  'disableNotification' => null,
  'policy' => [
    'assignments' => [
        [
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => ''
  ],
  'resource' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/policies:set');
$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}}/v1alpha1/policies:set' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "disableNotification": false,
  "policy": {
    "assignments": [
      {
        "members": [],
        "role": ""
      }
    ],
    "etag": ""
  },
  "resource": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/policies:set' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "disableNotification": false,
  "policy": {
    "assignments": [
      {
        "members": [],
        "role": ""
      }
    ],
    "etag": ""
  },
  "resource": ""
}'

import http.client

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

payload = "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/policies:set", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/policies:set"

payload = {
    "disableNotification": False,
    "policy": {
        "assignments": [
            {
                "members": [],
                "role": ""
            }
        ],
        "etag": ""
    },
    "resource": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/policies:set"

payload <- "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\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}}/v1alpha1/policies:set")

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  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\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/v1alpha1/policies:set') do |req|
  req.body = "{\n  \"disableNotification\": false,\n  \"policy\": {\n    \"assignments\": [\n      {\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\"\n  },\n  \"resource\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "disableNotification": false,
        "policy": json!({
            "assignments": (
                json!({
                    "members": (),
                    "role": ""
                })
            ),
            "etag": ""
        }),
        "resource": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "disableNotification": false,
  "policy": {
    "assignments": [
      {
        "members": [],
        "role": ""
      }
    ],
    "etag": ""
  },
  "resource": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/policies:set \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "disableNotification": false,\n  "policy": {\n    "assignments": [\n      {\n        "members": [],\n        "role": ""\n      }\n    ],\n    "etag": ""\n  },\n  "resource": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/policies:set

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "disableNotification": false,
  "policy": [
    "assignments": [
      [
        "members": [],
        "role": ""
      ]
    ],
    "etag": ""
  ],
  "resource": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1alpha1/policies:test");

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  \"permissions\": [],\n  \"resource\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1alpha1/policies:test" {:content-type :json
                                                                   :form-params {:permissions []
                                                                                 :resource ""}})

require "http/client"

url = "{{baseUrl}}/v1alpha1/policies:test"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissions\": [],\n  \"resource\": \"\"\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}}/v1alpha1/policies:test"),
    Content = new StringContent("{\n  \"permissions\": [],\n  \"resource\": \"\"\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}}/v1alpha1/policies:test");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissions\": [],\n  \"resource\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1alpha1/policies:test"

	payload := strings.NewReader("{\n  \"permissions\": [],\n  \"resource\": \"\"\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/v1alpha1/policies:test HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "permissions": [],
  "resource": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1alpha1/policies:test")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissions\": [],\n  \"resource\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1alpha1/policies:test")
  .header("content-type", "application/json")
  .body("{\n  \"permissions\": [],\n  \"resource\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  permissions: [],
  resource: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1alpha1/policies:test');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/policies:test',
  headers: {'content-type': 'application/json'},
  data: {permissions: [], resource: ''}
};

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

const url = '{{baseUrl}}/v1alpha1/policies:test';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[],"resource":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1alpha1/policies:test',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissions": [],\n  "resource": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"permissions\": [],\n  \"resource\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1alpha1/policies:test")
  .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/v1alpha1/policies:test',
  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({permissions: [], resource: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1alpha1/policies:test',
  headers: {'content-type': 'application/json'},
  body: {permissions: [], resource: ''},
  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}}/v1alpha1/policies:test');

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

req.type('json');
req.send({
  permissions: [],
  resource: ''
});

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}}/v1alpha1/policies:test',
  headers: {'content-type': 'application/json'},
  data: {permissions: [], resource: ''}
};

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

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

const url = '{{baseUrl}}/v1alpha1/policies:test';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[],"resource":""}'
};

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 = @{ @"permissions": @[  ],
                              @"resource": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1alpha1/policies:test"]
                                                       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}}/v1alpha1/policies:test" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissions\": [],\n  \"resource\": \"\"\n}" in

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

 "{{baseUrl}}/v1alpha1/policies:test",
  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([
    'permissions' => [
        
    ],
    'resource' => ''
  ]),
  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}}/v1alpha1/policies:test', [
  'body' => '{
  "permissions": [],
  "resource": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1alpha1/policies:test');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'permissions' => [
    
  ],
  'resource' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1alpha1/policies:test');
$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}}/v1alpha1/policies:test' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": [],
  "resource": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1alpha1/policies:test' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": [],
  "resource": ""
}'

import http.client

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

payload = "{\n  \"permissions\": [],\n  \"resource\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1alpha1/policies:test", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1alpha1/policies:test"

payload = {
    "permissions": [],
    "resource": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1alpha1/policies:test"

payload <- "{\n  \"permissions\": [],\n  \"resource\": \"\"\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}}/v1alpha1/policies:test")

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  \"permissions\": [],\n  \"resource\": \"\"\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/v1alpha1/policies:test') do |req|
  req.body = "{\n  \"permissions\": [],\n  \"resource\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "permissions": (),
        "resource": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "permissions": [],
  "resource": ""
}' |  \
  http POST {{baseUrl}}/v1alpha1/policies:test \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissions": [],\n  "resource": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1alpha1/policies:test

import Foundation

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

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

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