CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/:parent/configurations" {:content-type :json
                                                                      :form-params {:companyName ""
                                                                                    :configurationId ""
                                                                                    :configurationName ""
                                                                                    :contactEmail ""
                                                                                    :contactPhone ""
                                                                                    :customMessage ""
                                                                                    :dpcExtras ""
                                                                                    :dpcResourcePath ""
                                                                                    :isDefault false
                                                                                    :name ""}})

require "http/client"

url = "{{baseUrl}}/v1/:parent/configurations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/:parent/configurations"),
    Content = new StringContent("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/:parent/configurations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/configurations"

	payload := strings.NewReader("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/v1/:parent/configurations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 222

{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:parent/configurations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:parent/configurations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:parent/configurations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/:parent/configurations")
  .header("content-type", "application/json")
  .body("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  companyName: '',
  configurationId: '',
  configurationName: '',
  contactEmail: '',
  contactPhone: '',
  customMessage: '',
  dpcExtras: '',
  dpcResourcePath: '',
  isDefault: false,
  name: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/configurations',
  headers: {'content-type': 'application/json'},
  data: {
    companyName: '',
    configurationId: '',
    configurationName: '',
    contactEmail: '',
    contactPhone: '',
    customMessage: '',
    dpcExtras: '',
    dpcResourcePath: '',
    isDefault: false,
    name: ''
  }
};

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

const url = '{{baseUrl}}/v1/:parent/configurations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"companyName":"","configurationId":"","configurationName":"","contactEmail":"","contactPhone":"","customMessage":"","dpcExtras":"","dpcResourcePath":"","isDefault":false,"name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:parent/configurations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "companyName": "",\n  "configurationId": "",\n  "configurationName": "",\n  "contactEmail": "",\n  "contactPhone": "",\n  "customMessage": "",\n  "dpcExtras": "",\n  "dpcResourcePath": "",\n  "isDefault": false,\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:parent/configurations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  companyName: '',
  configurationId: '',
  configurationName: '',
  contactEmail: '',
  contactPhone: '',
  customMessage: '',
  dpcExtras: '',
  dpcResourcePath: '',
  isDefault: false,
  name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/configurations',
  headers: {'content-type': 'application/json'},
  body: {
    companyName: '',
    configurationId: '',
    configurationName: '',
    contactEmail: '',
    contactPhone: '',
    customMessage: '',
    dpcExtras: '',
    dpcResourcePath: '',
    isDefault: false,
    name: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/:parent/configurations');

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

req.type('json');
req.send({
  companyName: '',
  configurationId: '',
  configurationName: '',
  contactEmail: '',
  contactPhone: '',
  customMessage: '',
  dpcExtras: '',
  dpcResourcePath: '',
  isDefault: false,
  name: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/configurations',
  headers: {'content-type': 'application/json'},
  data: {
    companyName: '',
    configurationId: '',
    configurationName: '',
    contactEmail: '',
    contactPhone: '',
    customMessage: '',
    dpcExtras: '',
    dpcResourcePath: '',
    isDefault: false,
    name: ''
  }
};

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

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

const url = '{{baseUrl}}/v1/:parent/configurations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"companyName":"","configurationId":"","configurationName":"","contactEmail":"","contactPhone":"","customMessage":"","dpcExtras":"","dpcResourcePath":"","isDefault":false,"name":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"companyName": @"",
                              @"configurationId": @"",
                              @"configurationName": @"",
                              @"contactEmail": @"",
                              @"contactPhone": @"",
                              @"customMessage": @"",
                              @"dpcExtras": @"",
                              @"dpcResourcePath": @"",
                              @"isDefault": @NO,
                              @"name": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/:parent/configurations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}" in

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

 "{{baseUrl}}/v1/:parent/configurations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'companyName' => '',
    'configurationId' => '',
    'configurationName' => '',
    'contactEmail' => '',
    'contactPhone' => '',
    'customMessage' => '',
    'dpcExtras' => '',
    'dpcResourcePath' => '',
    'isDefault' => null,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1/:parent/configurations', [
  'body' => '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'companyName' => '',
  'configurationId' => '',
  'configurationName' => '',
  'contactEmail' => '',
  'contactPhone' => '',
  'customMessage' => '',
  'dpcExtras' => '',
  'dpcResourcePath' => '',
  'isDefault' => null,
  'name' => ''
]));

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

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

append(json_encode([
  'companyName' => '',
  'configurationId' => '',
  'configurationName' => '',
  'contactEmail' => '',
  'contactPhone' => '',
  'customMessage' => '',
  'dpcExtras' => '',
  'dpcResourcePath' => '',
  'isDefault' => null,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/:parent/configurations');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:parent/configurations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:parent/configurations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}'

import http.client

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

payload = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/:parent/configurations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/:parent/configurations"

payload = {
    "companyName": "",
    "configurationId": "",
    "configurationName": "",
    "contactEmail": "",
    "contactPhone": "",
    "customMessage": "",
    "dpcExtras": "",
    "dpcResourcePath": "",
    "isDefault": False,
    "name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/configurations"

payload <- "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/configurations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/:parent/configurations') do |req|
  req.body = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "companyName": "",
        "configurationId": "",
        "configurationName": "",
        "contactEmail": "",
        "contactPhone": "",
        "customMessage": "",
        "dpcExtras": "",
        "dpcResourcePath": "",
        "isDefault": false,
        "name": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}' |  \
  http POST {{baseUrl}}/v1/:parent/configurations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "companyName": "",\n  "configurationId": "",\n  "configurationName": "",\n  "contactEmail": "",\n  "contactPhone": "",\n  "customMessage": "",\n  "dpcExtras": "",\n  "dpcResourcePath": "",\n  "isDefault": false,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/:parent/configurations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/: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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:parent/configurations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/:parent/configurations")

require "http/client"

url = "{{baseUrl}}/v1/:parent/configurations"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/:parent/configurations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/configurations"

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

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

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

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

}

GET /baseUrl/v1/:parent/configurations HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:parent/configurations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:parent/configurations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/:parent/configurations")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/v1/:parent/configurations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:parent/configurations'};

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

const url = '{{baseUrl}}/v1/:parent/configurations';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:parent/configurations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/:parent/configurations'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/v1/:parent/configurations'};

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

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

const url = '{{baseUrl}}/v1/:parent/configurations';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/:parent/configurations" in

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

 "{{baseUrl}}/v1/:parent/configurations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v1/:parent/configurations');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/:parent/configurations")

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

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

import requests

url = "{{baseUrl}}/v1/:parent/configurations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/configurations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/configurations")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v1/:parent/configurations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/:parent/configurations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/:parent/configurations

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/: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  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1/:name" {:content-type :json
                                                      :form-params {:companyName ""
                                                                    :configurationId ""
                                                                    :configurationName ""
                                                                    :contactEmail ""
                                                                    :contactPhone ""
                                                                    :customMessage ""
                                                                    :dpcExtras ""
                                                                    :dpcResourcePath ""
                                                                    :isDefault false
                                                                    :name ""}})

require "http/client"

url = "{{baseUrl}}/v1/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\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}}/v1/:name"),
    Content = new StringContent("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/:name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\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/v1/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 222

{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1/:name")
  .header("content-type", "application/json")
  .body("{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  companyName: '',
  configurationId: '',
  configurationName: '',
  contactEmail: '',
  contactPhone: '',
  customMessage: '',
  dpcExtras: '',
  dpcResourcePath: '',
  isDefault: false,
  name: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1/:name',
  headers: {'content-type': 'application/json'},
  data: {
    companyName: '',
    configurationId: '',
    configurationName: '',
    contactEmail: '',
    contactPhone: '',
    customMessage: '',
    dpcExtras: '',
    dpcResourcePath: '',
    isDefault: false,
    name: ''
  }
};

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

const url = '{{baseUrl}}/v1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"companyName":"","configurationId":"","configurationName":"","contactEmail":"","contactPhone":"","customMessage":"","dpcExtras":"","dpcResourcePath":"","isDefault":false,"name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "companyName": "",\n  "configurationId": "",\n  "configurationName": "",\n  "contactEmail": "",\n  "contactPhone": "",\n  "customMessage": "",\n  "dpcExtras": "",\n  "dpcResourcePath": "",\n  "isDefault": false,\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/: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/v1/: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({
  companyName: '',
  configurationId: '',
  configurationName: '',
  contactEmail: '',
  contactPhone: '',
  customMessage: '',
  dpcExtras: '',
  dpcResourcePath: '',
  isDefault: false,
  name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1/:name',
  headers: {'content-type': 'application/json'},
  body: {
    companyName: '',
    configurationId: '',
    configurationName: '',
    contactEmail: '',
    contactPhone: '',
    customMessage: '',
    dpcExtras: '',
    dpcResourcePath: '',
    isDefault: false,
    name: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/v1/:name');

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

req.type('json');
req.send({
  companyName: '',
  configurationId: '',
  configurationName: '',
  contactEmail: '',
  contactPhone: '',
  customMessage: '',
  dpcExtras: '',
  dpcResourcePath: '',
  isDefault: false,
  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: 'PATCH',
  url: '{{baseUrl}}/v1/:name',
  headers: {'content-type': 'application/json'},
  data: {
    companyName: '',
    configurationId: '',
    configurationName: '',
    contactEmail: '',
    contactPhone: '',
    customMessage: '',
    dpcExtras: '',
    dpcResourcePath: '',
    isDefault: false,
    name: ''
  }
};

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

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

const url = '{{baseUrl}}/v1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"companyName":"","configurationId":"","configurationName":"","contactEmail":"","contactPhone":"","customMessage":"","dpcExtras":"","dpcResourcePath":"","isDefault":false,"name":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"companyName": @"",
                              @"configurationId": @"",
                              @"configurationName": @"",
                              @"contactEmail": @"",
                              @"contactPhone": @"",
                              @"customMessage": @"",
                              @"dpcExtras": @"",
                              @"dpcResourcePath": @"",
                              @"isDefault": @NO,
                              @"name": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/: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}}/v1/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}" in

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

 "{{baseUrl}}/v1/: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([
    'companyName' => '',
    'configurationId' => '',
    'configurationName' => '',
    'contactEmail' => '',
    'contactPhone' => '',
    'customMessage' => '',
    'dpcExtras' => '',
    'dpcResourcePath' => '',
    'isDefault' => null,
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/v1/:name', [
  'body' => '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'companyName' => '',
  'configurationId' => '',
  'configurationName' => '',
  'contactEmail' => '',
  'contactPhone' => '',
  'customMessage' => '',
  'dpcExtras' => '',
  'dpcResourcePath' => '',
  'isDefault' => null,
  'name' => ''
]));

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

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

append(json_encode([
  'companyName' => '',
  'configurationId' => '',
  'configurationName' => '',
  'contactEmail' => '',
  'contactPhone' => '',
  'customMessage' => '',
  'dpcExtras' => '',
  'dpcResourcePath' => '',
  'isDefault' => null,
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/: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}}/v1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}'

import http.client

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

payload = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"

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

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

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

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

import requests

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

payload = {
    "companyName": "",
    "configurationId": "",
    "configurationName": "",
    "contactEmail": "",
    "contactPhone": "",
    "customMessage": "",
    "dpcExtras": "",
    "dpcResourcePath": "",
    "isDefault": False,
    "name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\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}}/v1/: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  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/v1/:name') do |req|
  req.body = "{\n  \"companyName\": \"\",\n  \"configurationId\": \"\",\n  \"configurationName\": \"\",\n  \"contactEmail\": \"\",\n  \"contactPhone\": \"\",\n  \"customMessage\": \"\",\n  \"dpcExtras\": \"\",\n  \"dpcResourcePath\": \"\",\n  \"isDefault\": false,\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "companyName": "",
        "configurationId": "",
        "configurationName": "",
        "contactEmail": "",
        "contactPhone": "",
        "customMessage": "",
        "dpcExtras": "",
        "dpcResourcePath": "",
        "isDefault": false,
        "name": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
}' |  \
  http PATCH {{baseUrl}}/v1/:name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "companyName": "",\n  "configurationId": "",\n  "configurationName": "",\n  "contactEmail": "",\n  "contactPhone": "",\n  "customMessage": "",\n  "dpcExtras": "",\n  "dpcResourcePath": "",\n  "isDefault": false,\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "companyName": "",
  "configurationId": "",
  "configurationName": "",
  "contactEmail": "",
  "contactPhone": "",
  "customMessage": "",
  "dpcExtras": "",
  "dpcResourcePath": "",
  "isDefault": false,
  "name": ""
] as [String : Any]

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

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

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  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/:parent/devices:applyConfiguration" {:content-type :json
                                                                                  :form-params {:configuration ""
                                                                                                :device {:deviceId ""
                                                                                                         :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                            :deviceType ""
                                                                                                                            :imei ""
                                                                                                                            :manufacturer ""
                                                                                                                            :meid ""
                                                                                                                            :model ""
                                                                                                                            :serialNumber ""}}}})

require "http/client"

url = "{{baseUrl}}/v1/:parent/devices:applyConfiguration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/:parent/devices:applyConfiguration"),
    Content = new StringContent("{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/:parent/devices:applyConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/devices:applyConfiguration"

	payload := strings.NewReader("{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/v1/:parent/devices:applyConfiguration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 264

{
  "configuration": "",
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:parent/devices:applyConfiguration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:parent/devices:applyConfiguration"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:parent/devices:applyConfiguration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/:parent/devices:applyConfiguration")
  .header("content-type", "application/json")
  .body("{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  configuration: '',
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/devices:applyConfiguration',
  headers: {'content-type': 'application/json'},
  data: {
    configuration: '',
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  }
};

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

const url = '{{baseUrl}}/v1/:parent/devices:applyConfiguration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configuration":"","device":{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:parent/devices:applyConfiguration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "configuration": "",\n  "device": {\n    "deviceId": "",\n    "deviceIdentifier": {\n      "chromeOsAttestedDeviceId": "",\n      "deviceType": "",\n      "imei": "",\n      "manufacturer": "",\n      "meid": "",\n      "model": "",\n      "serialNumber": ""\n    }\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:parent/devices:applyConfiguration")
  .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/v1/:parent/devices:applyConfiguration',
  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({
  configuration: '',
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/devices:applyConfiguration',
  headers: {'content-type': 'application/json'},
  body: {
    configuration: '',
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  },
  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}}/v1/:parent/devices:applyConfiguration');

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

req.type('json');
req.send({
  configuration: '',
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
});

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}}/v1/:parent/devices:applyConfiguration',
  headers: {'content-type': 'application/json'},
  data: {
    configuration: '',
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  }
};

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

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

const url = '{{baseUrl}}/v1/:parent/devices:applyConfiguration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configuration":"","device":{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""}}}'
};

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 = @{ @"configuration": @"",
                              @"device": @{ @"deviceId": @"", @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:parent/devices:applyConfiguration"]
                                                       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}}/v1/:parent/devices:applyConfiguration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/v1/:parent/devices:applyConfiguration",
  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([
    'configuration' => '',
    'device' => [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ]
    ]
  ]),
  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}}/v1/:parent/devices:applyConfiguration', [
  'body' => '{
  "configuration": "",
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'configuration' => '',
  'device' => [
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'configuration' => '',
  'device' => [
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:parent/devices:applyConfiguration');
$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}}/v1/:parent/devices:applyConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configuration": "",
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:parent/devices:applyConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configuration": "",
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1/:parent/devices:applyConfiguration"

payload = {
    "configuration": "",
    "device": {
        "deviceId": "",
        "deviceIdentifier": {
            "chromeOsAttestedDeviceId": "",
            "deviceType": "",
            "imei": "",
            "manufacturer": "",
            "meid": "",
            "model": "",
            "serialNumber": ""
        }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/devices:applyConfiguration"

payload <- "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/devices:applyConfiguration")

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  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/:parent/devices:applyConfiguration') do |req|
  req.body = "{\n  \"configuration\": \"\",\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "configuration": "",
        "device": json!({
            "deviceId": "",
            "deviceIdentifier": json!({
                "chromeOsAttestedDeviceId": "",
                "deviceType": "",
                "imei": "",
                "manufacturer": "",
                "meid": "",
                "model": "",
                "serialNumber": ""
            })
        })
    });

    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 '{
  "configuration": "",
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/v1/:parent/devices:applyConfiguration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "configuration": "",\n  "device": {\n    "deviceId": "",\n    "deviceIdentifier": {\n      "chromeOsAttestedDeviceId": "",\n      "deviceType": "",\n      "imei": "",\n      "manufacturer": "",\n      "meid": "",\n      "model": "",\n      "serialNumber": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/:parent/devices:applyConfiguration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "configuration": "",
  "device": [
    "deviceId": "",
    "deviceIdentifier": [
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    ]
  ]
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/v1/: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}}/v1/: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}}/v1/:parent/devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/: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/v1/: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}}/v1/: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}}/v1/: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}}/v1/: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}}/v1/: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}}/v1/: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}}/v1/:parent/devices" in

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/: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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:parent/devices:removeConfiguration");

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    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/:parent/devices:removeConfiguration" {:content-type :json
                                                                                   :form-params {:device {:deviceId ""
                                                                                                          :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                             :deviceType ""
                                                                                                                             :imei ""
                                                                                                                             :manufacturer ""
                                                                                                                             :meid ""
                                                                                                                             :model ""
                                                                                                                             :serialNumber ""}}}})

require "http/client"

url = "{{baseUrl}}/v1/:parent/devices:removeConfiguration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/:parent/devices:removeConfiguration"),
    Content = new StringContent("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/:parent/devices:removeConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/devices:removeConfiguration"

	payload := strings.NewReader("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/v1/:parent/devices:removeConfiguration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 241

{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:parent/devices:removeConfiguration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:parent/devices:removeConfiguration"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:parent/devices:removeConfiguration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/:parent/devices:removeConfiguration")
  .header("content-type", "application/json")
  .body("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/devices:removeConfiguration',
  headers: {'content-type': 'application/json'},
  data: {
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  }
};

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

const url = '{{baseUrl}}/v1/:parent/devices:removeConfiguration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"device":{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:parent/devices:removeConfiguration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "device": {\n    "deviceId": "",\n    "deviceIdentifier": {\n      "chromeOsAttestedDeviceId": "",\n      "deviceType": "",\n      "imei": "",\n      "manufacturer": "",\n      "meid": "",\n      "model": "",\n      "serialNumber": ""\n    }\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:parent/devices:removeConfiguration")
  .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/v1/:parent/devices:removeConfiguration',
  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: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/devices:removeConfiguration',
  headers: {'content-type': 'application/json'},
  body: {
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  },
  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}}/v1/:parent/devices:removeConfiguration');

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

req.type('json');
req.send({
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
});

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}}/v1/:parent/devices:removeConfiguration',
  headers: {'content-type': 'application/json'},
  data: {
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  }
};

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

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

const url = '{{baseUrl}}/v1/:parent/devices:removeConfiguration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"device":{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""}}}'
};

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": @{ @"deviceId": @"", @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:parent/devices:removeConfiguration"]
                                                       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}}/v1/:parent/devices:removeConfiguration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/v1/:parent/devices:removeConfiguration",
  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' => [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ]
    ]
  ]),
  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}}/v1/:parent/devices:removeConfiguration', [
  'body' => '{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'device' => [
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'device' => [
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:parent/devices:removeConfiguration');
$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}}/v1/:parent/devices:removeConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:parent/devices:removeConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1/:parent/devices:removeConfiguration"

payload = { "device": {
        "deviceId": "",
        "deviceIdentifier": {
            "chromeOsAttestedDeviceId": "",
            "deviceType": "",
            "imei": "",
            "manufacturer": "",
            "meid": "",
            "model": "",
            "serialNumber": ""
        }
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/devices:removeConfiguration"

payload <- "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/devices:removeConfiguration")

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    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/:parent/devices:removeConfiguration') do |req|
  req.body = "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"device": json!({
            "deviceId": "",
            "deviceIdentifier": json!({
                "chromeOsAttestedDeviceId": "",
                "deviceType": "",
                "imei": "",
                "manufacturer": "",
                "meid": "",
                "model": "",
                "serialNumber": ""
            })
        })});

    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": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/v1/:parent/devices:removeConfiguration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "device": {\n    "deviceId": "",\n    "deviceIdentifier": {\n      "chromeOsAttestedDeviceId": "",\n      "deviceType": "",\n      "imei": "",\n      "manufacturer": "",\n      "meid": "",\n      "model": "",\n      "serialNumber": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/:parent/devices:removeConfiguration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["device": [
    "deviceId": "",
    "deviceIdentifier": [
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:parent/devices:removeConfiguration")! 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}}/v1/:parent/devices:unclaim");

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    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/:parent/devices:unclaim" {:content-type :json
                                                                       :form-params {:device {:deviceId ""
                                                                                              :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                 :deviceType ""
                                                                                                                 :imei ""
                                                                                                                 :manufacturer ""
                                                                                                                 :meid ""
                                                                                                                 :model ""
                                                                                                                 :serialNumber ""}}}})

require "http/client"

url = "{{baseUrl}}/v1/:parent/devices:unclaim"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/:parent/devices:unclaim"),
    Content = new StringContent("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/:parent/devices:unclaim");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/devices:unclaim"

	payload := strings.NewReader("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/v1/:parent/devices:unclaim HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 241

{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:parent/devices:unclaim")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:parent/devices:unclaim"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:parent/devices:unclaim")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/:parent/devices:unclaim")
  .header("content-type", "application/json")
  .body("{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/devices:unclaim',
  headers: {'content-type': 'application/json'},
  data: {
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  }
};

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

const url = '{{baseUrl}}/v1/:parent/devices:unclaim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"device":{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:parent/devices:unclaim',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "device": {\n    "deviceId": "",\n    "deviceIdentifier": {\n      "chromeOsAttestedDeviceId": "",\n      "deviceType": "",\n      "imei": "",\n      "manufacturer": "",\n      "meid": "",\n      "model": "",\n      "serialNumber": ""\n    }\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:parent/devices:unclaim")
  .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/v1/:parent/devices:unclaim',
  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: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/devices:unclaim',
  headers: {'content-type': 'application/json'},
  body: {
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  },
  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}}/v1/:parent/devices:unclaim');

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

req.type('json');
req.send({
  device: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    }
  }
});

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}}/v1/:parent/devices:unclaim',
  headers: {'content-type': 'application/json'},
  data: {
    device: {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      }
    }
  }
};

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

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

const url = '{{baseUrl}}/v1/:parent/devices:unclaim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"device":{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""}}}'
};

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": @{ @"deviceId": @"", @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:parent/devices:unclaim"]
                                                       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}}/v1/:parent/devices:unclaim" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/v1/:parent/devices:unclaim",
  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' => [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ]
    ]
  ]),
  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}}/v1/:parent/devices:unclaim', [
  'body' => '{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'device' => [
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'device' => [
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:parent/devices:unclaim');
$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}}/v1/:parent/devices:unclaim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:parent/devices:unclaim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "device": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1/:parent/devices:unclaim"

payload = { "device": {
        "deviceId": "",
        "deviceIdentifier": {
            "chromeOsAttestedDeviceId": "",
            "deviceType": "",
            "imei": "",
            "manufacturer": "",
            "meid": "",
            "model": "",
            "serialNumber": ""
        }
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/devices:unclaim"

payload <- "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/devices:unclaim")

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    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/:parent/devices:unclaim') do |req|
  req.body = "{\n  \"device\": {\n    \"deviceId\": \"\",\n    \"deviceIdentifier\": {\n      \"chromeOsAttestedDeviceId\": \"\",\n      \"deviceType\": \"\",\n      \"imei\": \"\",\n      \"manufacturer\": \"\",\n      \"meid\": \"\",\n      \"model\": \"\",\n      \"serialNumber\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"device": json!({
            "deviceId": "",
            "deviceIdentifier": json!({
                "chromeOsAttestedDeviceId": "",
                "deviceType": "",
                "imei": "",
                "manufacturer": "",
                "meid": "",
                "model": "",
                "serialNumber": ""
            })
        })});

    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": {
    "deviceId": "",
    "deviceIdentifier": {
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/v1/:parent/devices:unclaim \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "device": {\n    "deviceId": "",\n    "deviceIdentifier": {\n      "chromeOsAttestedDeviceId": "",\n      "deviceType": "",\n      "imei": "",\n      "manufacturer": "",\n      "meid": "",\n      "model": "",\n      "serialNumber": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/:parent/devices:unclaim

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["device": [
    "deviceId": "",
    "deviceIdentifier": [
      "chromeOsAttestedDeviceId": "",
      "deviceType": "",
      "imei": "",
      "manufacturer": "",
      "meid": "",
      "model": "",
      "serialNumber": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:parent/devices:unclaim")! 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}}/v1/:parent/dpcs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/:parent/dpcs")

require "http/client"

url = "{{baseUrl}}/v1/:parent/dpcs"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/dpcs"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:parent/dpcs'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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}}/v1/:parent/dpcs'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/:parent/dpcs")

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

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

import requests

url = "{{baseUrl}}/v1/:parent/dpcs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/dpcs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/dpcs")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/:parent/dpcs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/:parent/dpcs

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

import Foundation

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

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  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/:parent/customers" {:content-type :json
                                                                 :form-params {:customer {:adminEmails []
                                                                                          :companyId ""
                                                                                          :companyName ""
                                                                                          :googleWorkspaceAccount {:customerId ""
                                                                                                                   :preProvisioningTokens []}
                                                                                          :languageCode ""
                                                                                          :name ""
                                                                                          :ownerEmails []
                                                                                          :skipWelcomeEmail false
                                                                                          :termsStatus ""}}})

require "http/client"

url = "{{baseUrl}}/v1/:parent/customers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\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}}/v1/:parent/customers"),
    Content = new StringContent("{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\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}}/v1/:parent/customers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/customers"

	payload := strings.NewReader("{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\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/v1/:parent/customers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 303

{
  "customer": {
    "adminEmails": [],
    "companyId": "",
    "companyName": "",
    "googleWorkspaceAccount": {
      "customerId": "",
      "preProvisioningTokens": []
    },
    "languageCode": "",
    "name": "",
    "ownerEmails": [],
    "skipWelcomeEmail": false,
    "termsStatus": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:parent/customers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:parent/customers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\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  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:parent/customers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/:parent/customers")
  .header("content-type", "application/json")
  .body("{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  customer: {
    adminEmails: [],
    companyId: '',
    companyName: '',
    googleWorkspaceAccount: {
      customerId: '',
      preProvisioningTokens: []
    },
    languageCode: '',
    name: '',
    ownerEmails: [],
    skipWelcomeEmail: false,
    termsStatus: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/customers',
  headers: {'content-type': 'application/json'},
  data: {
    customer: {
      adminEmails: [],
      companyId: '',
      companyName: '',
      googleWorkspaceAccount: {customerId: '', preProvisioningTokens: []},
      languageCode: '',
      name: '',
      ownerEmails: [],
      skipWelcomeEmail: false,
      termsStatus: ''
    }
  }
};

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

const url = '{{baseUrl}}/v1/:parent/customers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customer":{"adminEmails":[],"companyId":"","companyName":"","googleWorkspaceAccount":{"customerId":"","preProvisioningTokens":[]},"languageCode":"","name":"","ownerEmails":[],"skipWelcomeEmail":false,"termsStatus":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:parent/customers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customer": {\n    "adminEmails": [],\n    "companyId": "",\n    "companyName": "",\n    "googleWorkspaceAccount": {\n      "customerId": "",\n      "preProvisioningTokens": []\n    },\n    "languageCode": "",\n    "name": "",\n    "ownerEmails": [],\n    "skipWelcomeEmail": false,\n    "termsStatus": ""\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  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:parent/customers")
  .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/v1/:parent/customers',
  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({
  customer: {
    adminEmails: [],
    companyId: '',
    companyName: '',
    googleWorkspaceAccount: {customerId: '', preProvisioningTokens: []},
    languageCode: '',
    name: '',
    ownerEmails: [],
    skipWelcomeEmail: false,
    termsStatus: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:parent/customers',
  headers: {'content-type': 'application/json'},
  body: {
    customer: {
      adminEmails: [],
      companyId: '',
      companyName: '',
      googleWorkspaceAccount: {customerId: '', preProvisioningTokens: []},
      languageCode: '',
      name: '',
      ownerEmails: [],
      skipWelcomeEmail: false,
      termsStatus: ''
    }
  },
  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}}/v1/:parent/customers');

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

req.type('json');
req.send({
  customer: {
    adminEmails: [],
    companyId: '',
    companyName: '',
    googleWorkspaceAccount: {
      customerId: '',
      preProvisioningTokens: []
    },
    languageCode: '',
    name: '',
    ownerEmails: [],
    skipWelcomeEmail: false,
    termsStatus: ''
  }
});

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}}/v1/:parent/customers',
  headers: {'content-type': 'application/json'},
  data: {
    customer: {
      adminEmails: [],
      companyId: '',
      companyName: '',
      googleWorkspaceAccount: {customerId: '', preProvisioningTokens: []},
      languageCode: '',
      name: '',
      ownerEmails: [],
      skipWelcomeEmail: false,
      termsStatus: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/v1/:parent/customers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customer":{"adminEmails":[],"companyId":"","companyName":"","googleWorkspaceAccount":{"customerId":"","preProvisioningTokens":[]},"languageCode":"","name":"","ownerEmails":[],"skipWelcomeEmail":false,"termsStatus":""}}'
};

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 = @{ @"customer": @{ @"adminEmails": @[  ], @"companyId": @"", @"companyName": @"", @"googleWorkspaceAccount": @{ @"customerId": @"", @"preProvisioningTokens": @[  ] }, @"languageCode": @"", @"name": @"", @"ownerEmails": @[  ], @"skipWelcomeEmail": @NO, @"termsStatus": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:parent/customers"]
                                                       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}}/v1/:parent/customers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1/:parent/customers",
  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([
    'customer' => [
        'adminEmails' => [
                
        ],
        'companyId' => '',
        'companyName' => '',
        'googleWorkspaceAccount' => [
                'customerId' => '',
                'preProvisioningTokens' => [
                                
                ]
        ],
        'languageCode' => '',
        'name' => '',
        'ownerEmails' => [
                
        ],
        'skipWelcomeEmail' => null,
        'termsStatus' => ''
    ]
  ]),
  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}}/v1/:parent/customers', [
  'body' => '{
  "customer": {
    "adminEmails": [],
    "companyId": "",
    "companyName": "",
    "googleWorkspaceAccount": {
      "customerId": "",
      "preProvisioningTokens": []
    },
    "languageCode": "",
    "name": "",
    "ownerEmails": [],
    "skipWelcomeEmail": false,
    "termsStatus": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customer' => [
    'adminEmails' => [
        
    ],
    'companyId' => '',
    'companyName' => '',
    'googleWorkspaceAccount' => [
        'customerId' => '',
        'preProvisioningTokens' => [
                
        ]
    ],
    'languageCode' => '',
    'name' => '',
    'ownerEmails' => [
        
    ],
    'skipWelcomeEmail' => null,
    'termsStatus' => ''
  ]
]));

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

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

append(json_encode([
  'customer' => [
    'adminEmails' => [
        
    ],
    'companyId' => '',
    'companyName' => '',
    'googleWorkspaceAccount' => [
        'customerId' => '',
        'preProvisioningTokens' => [
                
        ]
    ],
    'languageCode' => '',
    'name' => '',
    'ownerEmails' => [
        
    ],
    'skipWelcomeEmail' => null,
    'termsStatus' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:parent/customers');
$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}}/v1/:parent/customers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customer": {
    "adminEmails": [],
    "companyId": "",
    "companyName": "",
    "googleWorkspaceAccount": {
      "customerId": "",
      "preProvisioningTokens": []
    },
    "languageCode": "",
    "name": "",
    "ownerEmails": [],
    "skipWelcomeEmail": false,
    "termsStatus": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:parent/customers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customer": {
    "adminEmails": [],
    "companyId": "",
    "companyName": "",
    "googleWorkspaceAccount": {
      "customerId": "",
      "preProvisioningTokens": []
    },
    "languageCode": "",
    "name": "",
    "ownerEmails": [],
    "skipWelcomeEmail": false,
    "termsStatus": ""
  }
}'

import http.client

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

payload = "{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1/:parent/customers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/:parent/customers"

payload = { "customer": {
        "adminEmails": [],
        "companyId": "",
        "companyName": "",
        "googleWorkspaceAccount": {
            "customerId": "",
            "preProvisioningTokens": []
        },
        "languageCode": "",
        "name": "",
        "ownerEmails": [],
        "skipWelcomeEmail": False,
        "termsStatus": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/customers"

payload <- "{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\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}}/v1/:parent/customers")

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  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\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/v1/:parent/customers') do |req|
  req.body = "{\n  \"customer\": {\n    \"adminEmails\": [],\n    \"companyId\": \"\",\n    \"companyName\": \"\",\n    \"googleWorkspaceAccount\": {\n      \"customerId\": \"\",\n      \"preProvisioningTokens\": []\n    },\n    \"languageCode\": \"\",\n    \"name\": \"\",\n    \"ownerEmails\": [],\n    \"skipWelcomeEmail\": false,\n    \"termsStatus\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"customer": json!({
            "adminEmails": (),
            "companyId": "",
            "companyName": "",
            "googleWorkspaceAccount": json!({
                "customerId": "",
                "preProvisioningTokens": ()
            }),
            "languageCode": "",
            "name": "",
            "ownerEmails": (),
            "skipWelcomeEmail": false,
            "termsStatus": ""
        })});

    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 '{
  "customer": {
    "adminEmails": [],
    "companyId": "",
    "companyName": "",
    "googleWorkspaceAccount": {
      "customerId": "",
      "preProvisioningTokens": []
    },
    "languageCode": "",
    "name": "",
    "ownerEmails": [],
    "skipWelcomeEmail": false,
    "termsStatus": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/:parent/customers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customer": {\n    "adminEmails": [],\n    "companyId": "",\n    "companyName": "",\n    "googleWorkspaceAccount": {\n      "customerId": "",\n      "preProvisioningTokens": []\n    },\n    "languageCode": "",\n    "name": "",\n    "ownerEmails": [],\n    "skipWelcomeEmail": false,\n    "termsStatus": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/:parent/customers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["customer": [
    "adminEmails": [],
    "companyId": "",
    "companyName": "",
    "googleWorkspaceAccount": [
      "customerId": "",
      "preProvisioningTokens": []
    ],
    "languageCode": "",
    "name": "",
    "ownerEmails": [],
    "skipWelcomeEmail": false,
    "termsStatus": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:parent/customers")! 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}}/v1/partners/:partnerId/customers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/partners/:partnerId/customers")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/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/v1/partners/:partnerId/customers HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/partners/:partnerId/customers'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/customers")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/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}}/v1/partners/:partnerId/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}}/v1/partners/:partnerId/customers" in

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

 "{{baseUrl}}/v1/partners/:partnerId/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}}/v1/partners/:partnerId/customers');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/customers');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/partners/:partnerId/customers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/customers' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v1/partners/:partnerId/customers")

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/customers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/customers"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/partners/:partnerId/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/v1/partners/:partnerId/customers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/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}}/v1/partners/:partnerId/customers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/customers

import Foundation

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

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  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:claim" {:content-type :json
                                                                                 :form-params {:customerId ""
                                                                                               :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                  :deviceType ""
                                                                                                                  :imei ""
                                                                                                                  :manufacturer ""
                                                                                                                  :meid ""
                                                                                                                  :model ""
                                                                                                                  :serialNumber ""}
                                                                                               :deviceMetadata {:entries {}}
                                                                                               :googleWorkspaceCustomerId ""
                                                                                               :preProvisioningToken ""
                                                                                               :sectionType ""
                                                                                               :simlockProfileId ""}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:claim"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\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}}/v1/partners/:partnerId/devices:claim"),
    Content = new StringContent("{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\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}}/v1/partners/:partnerId/devices:claim");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:claim"

	payload := strings.NewReader("{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\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/v1/partners/:partnerId/devices:claim HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 362

{
  "customerId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "deviceMetadata": {
    "entries": {}
  },
  "googleWorkspaceCustomerId": "",
  "preProvisioningToken": "",
  "sectionType": "",
  "simlockProfileId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:claim")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:claim"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\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  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:claim")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:claim")
  .header("content-type", "application/json")
  .body("{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customerId: '',
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  deviceMetadata: {
    entries: {}
  },
  googleWorkspaceCustomerId: '',
  preProvisioningToken: '',
  sectionType: '',
  simlockProfileId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:claim');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:claim',
  headers: {'content-type': 'application/json'},
  data: {
    customerId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    deviceMetadata: {entries: {}},
    googleWorkspaceCustomerId: '',
    preProvisioningToken: '',
    sectionType: '',
    simlockProfileId: ''
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:claim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customerId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"deviceMetadata":{"entries":{}},"googleWorkspaceCustomerId":"","preProvisioningToken":"","sectionType":"","simlockProfileId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:claim',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customerId": "",\n  "deviceIdentifier": {\n    "chromeOsAttestedDeviceId": "",\n    "deviceType": "",\n    "imei": "",\n    "manufacturer": "",\n    "meid": "",\n    "model": "",\n    "serialNumber": ""\n  },\n  "deviceMetadata": {\n    "entries": {}\n  },\n  "googleWorkspaceCustomerId": "",\n  "preProvisioningToken": "",\n  "sectionType": "",\n  "simlockProfileId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:claim")
  .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/v1/partners/:partnerId/devices:claim',
  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({
  customerId: '',
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  deviceMetadata: {entries: {}},
  googleWorkspaceCustomerId: '',
  preProvisioningToken: '',
  sectionType: '',
  simlockProfileId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:claim',
  headers: {'content-type': 'application/json'},
  body: {
    customerId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    deviceMetadata: {entries: {}},
    googleWorkspaceCustomerId: '',
    preProvisioningToken: '',
    sectionType: '',
    simlockProfileId: ''
  },
  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}}/v1/partners/:partnerId/devices:claim');

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

req.type('json');
req.send({
  customerId: '',
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  deviceMetadata: {
    entries: {}
  },
  googleWorkspaceCustomerId: '',
  preProvisioningToken: '',
  sectionType: '',
  simlockProfileId: ''
});

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}}/v1/partners/:partnerId/devices:claim',
  headers: {'content-type': 'application/json'},
  data: {
    customerId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    deviceMetadata: {entries: {}},
    googleWorkspaceCustomerId: '',
    preProvisioningToken: '',
    sectionType: '',
    simlockProfileId: ''
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:claim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customerId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"deviceMetadata":{"entries":{}},"googleWorkspaceCustomerId":"","preProvisioningToken":"","sectionType":"","simlockProfileId":""}'
};

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 = @{ @"customerId": @"",
                              @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" },
                              @"deviceMetadata": @{ @"entries": @{  } },
                              @"googleWorkspaceCustomerId": @"",
                              @"preProvisioningToken": @"",
                              @"sectionType": @"",
                              @"simlockProfileId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:claim"]
                                                       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}}/v1/partners/:partnerId/devices:claim" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:claim",
  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([
    'customerId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ],
    'deviceMetadata' => [
        'entries' => [
                
        ]
    ],
    'googleWorkspaceCustomerId' => '',
    'preProvisioningToken' => '',
    'sectionType' => '',
    'simlockProfileId' => ''
  ]),
  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}}/v1/partners/:partnerId/devices:claim', [
  'body' => '{
  "customerId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "deviceMetadata": {
    "entries": {}
  },
  "googleWorkspaceCustomerId": "",
  "preProvisioningToken": "",
  "sectionType": "",
  "simlockProfileId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:claim');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customerId' => '',
  'deviceIdentifier' => [
    'chromeOsAttestedDeviceId' => '',
    'deviceType' => '',
    'imei' => '',
    'manufacturer' => '',
    'meid' => '',
    'model' => '',
    'serialNumber' => ''
  ],
  'deviceMetadata' => [
    'entries' => [
        
    ]
  ],
  'googleWorkspaceCustomerId' => '',
  'preProvisioningToken' => '',
  'sectionType' => '',
  'simlockProfileId' => ''
]));

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

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

append(json_encode([
  'customerId' => '',
  'deviceIdentifier' => [
    'chromeOsAttestedDeviceId' => '',
    'deviceType' => '',
    'imei' => '',
    'manufacturer' => '',
    'meid' => '',
    'model' => '',
    'serialNumber' => ''
  ],
  'deviceMetadata' => [
    'entries' => [
        
    ]
  ],
  'googleWorkspaceCustomerId' => '',
  'preProvisioningToken' => '',
  'sectionType' => '',
  'simlockProfileId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:claim');
$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}}/v1/partners/:partnerId/devices:claim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customerId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "deviceMetadata": {
    "entries": {}
  },
  "googleWorkspaceCustomerId": "",
  "preProvisioningToken": "",
  "sectionType": "",
  "simlockProfileId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:claim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customerId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "deviceMetadata": {
    "entries": {}
  },
  "googleWorkspaceCustomerId": "",
  "preProvisioningToken": "",
  "sectionType": "",
  "simlockProfileId": ""
}'

import http.client

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

payload = "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:claim", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:claim"

payload = {
    "customerId": "",
    "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
    },
    "deviceMetadata": { "entries": {} },
    "googleWorkspaceCustomerId": "",
    "preProvisioningToken": "",
    "sectionType": "",
    "simlockProfileId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:claim"

payload <- "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\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}}/v1/partners/:partnerId/devices:claim")

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  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\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/v1/partners/:partnerId/devices:claim') do |req|
  req.body = "{\n  \"customerId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"deviceMetadata\": {\n    \"entries\": {}\n  },\n  \"googleWorkspaceCustomerId\": \"\",\n  \"preProvisioningToken\": \"\",\n  \"sectionType\": \"\",\n  \"simlockProfileId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:claim";

    let payload = json!({
        "customerId": "",
        "deviceIdentifier": json!({
            "chromeOsAttestedDeviceId": "",
            "deviceType": "",
            "imei": "",
            "manufacturer": "",
            "meid": "",
            "model": "",
            "serialNumber": ""
        }),
        "deviceMetadata": json!({"entries": json!({})}),
        "googleWorkspaceCustomerId": "",
        "preProvisioningToken": "",
        "sectionType": "",
        "simlockProfileId": ""
    });

    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 '{
  "customerId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "deviceMetadata": {
    "entries": {}
  },
  "googleWorkspaceCustomerId": "",
  "preProvisioningToken": "",
  "sectionType": "",
  "simlockProfileId": ""
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:claim \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customerId": "",\n  "deviceIdentifier": {\n    "chromeOsAttestedDeviceId": "",\n    "deviceType": "",\n    "imei": "",\n    "manufacturer": "",\n    "meid": "",\n    "model": "",\n    "serialNumber": ""\n  },\n  "deviceMetadata": {\n    "entries": {}\n  },\n  "googleWorkspaceCustomerId": "",\n  "preProvisioningToken": "",\n  "sectionType": "",\n  "simlockProfileId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:claim

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customerId": "",
  "deviceIdentifier": [
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  ],
  "deviceMetadata": ["entries": []],
  "googleWorkspaceCustomerId": "",
  "preProvisioningToken": "",
  "sectionType": "",
  "simlockProfileId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:claim")! 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}}/v1/partners/:partnerId/devices:claimAsync");

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  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync" {:content-type :json
                                                                                      :form-params {:claims [{:customerId ""
                                                                                                              :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                                 :deviceType ""
                                                                                                                                 :imei ""
                                                                                                                                 :manufacturer ""
                                                                                                                                 :meid ""
                                                                                                                                 :model ""
                                                                                                                                 :serialNumber ""}
                                                                                                              :deviceMetadata {:entries {}}
                                                                                                              :googleWorkspaceCustomerId ""
                                                                                                              :preProvisioningToken ""
                                                                                                              :sectionType ""
                                                                                                              :simlockProfileId ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"),
    Content = new StringContent("{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"

	payload := strings.NewReader("{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/partners/:partnerId/devices:claimAsync HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 460

{
  "claims": [
    {
      "customerId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      },
      "googleWorkspaceCustomerId": "",
      "preProvisioningToken": "",
      "sectionType": "",
      "simlockProfileId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync")
  .header("content-type", "application/json")
  .body("{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  claims: [
    {
      customerId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      deviceMetadata: {
        entries: {}
      },
      googleWorkspaceCustomerId: '',
      preProvisioningToken: '',
      sectionType: '',
      simlockProfileId: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync',
  headers: {'content-type': 'application/json'},
  data: {
    claims: [
      {
        customerId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        deviceMetadata: {entries: {}},
        googleWorkspaceCustomerId: '',
        preProvisioningToken: '',
        sectionType: '',
        simlockProfileId: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"claims":[{"customerId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"deviceMetadata":{"entries":{}},"googleWorkspaceCustomerId":"","preProvisioningToken":"","sectionType":"","simlockProfileId":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "claims": [\n    {\n      "customerId": "",\n      "deviceIdentifier": {\n        "chromeOsAttestedDeviceId": "",\n        "deviceType": "",\n        "imei": "",\n        "manufacturer": "",\n        "meid": "",\n        "model": "",\n        "serialNumber": ""\n      },\n      "deviceMetadata": {\n        "entries": {}\n      },\n      "googleWorkspaceCustomerId": "",\n      "preProvisioningToken": "",\n      "sectionType": "",\n      "simlockProfileId": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync")
  .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/v1/partners/:partnerId/devices:claimAsync',
  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({
  claims: [
    {
      customerId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      deviceMetadata: {entries: {}},
      googleWorkspaceCustomerId: '',
      preProvisioningToken: '',
      sectionType: '',
      simlockProfileId: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync',
  headers: {'content-type': 'application/json'},
  body: {
    claims: [
      {
        customerId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        deviceMetadata: {entries: {}},
        googleWorkspaceCustomerId: '',
        preProvisioningToken: '',
        sectionType: '',
        simlockProfileId: ''
      }
    ]
  },
  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}}/v1/partners/:partnerId/devices:claimAsync');

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

req.type('json');
req.send({
  claims: [
    {
      customerId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      deviceMetadata: {
        entries: {}
      },
      googleWorkspaceCustomerId: '',
      preProvisioningToken: '',
      sectionType: '',
      simlockProfileId: ''
    }
  ]
});

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}}/v1/partners/:partnerId/devices:claimAsync',
  headers: {'content-type': 'application/json'},
  data: {
    claims: [
      {
        customerId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        deviceMetadata: {entries: {}},
        googleWorkspaceCustomerId: '',
        preProvisioningToken: '',
        sectionType: '',
        simlockProfileId: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"claims":[{"customerId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"deviceMetadata":{"entries":{}},"googleWorkspaceCustomerId":"","preProvisioningToken":"","sectionType":"","simlockProfileId":""}]}'
};

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 = @{ @"claims": @[ @{ @"customerId": @"", @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" }, @"deviceMetadata": @{ @"entries": @{  } }, @"googleWorkspaceCustomerId": @"", @"preProvisioningToken": @"", @"sectionType": @"", @"simlockProfileId": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"]
                                                       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}}/v1/partners/:partnerId/devices:claimAsync" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync",
  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([
    'claims' => [
        [
                'customerId' => '',
                'deviceIdentifier' => [
                                'chromeOsAttestedDeviceId' => '',
                                'deviceType' => '',
                                'imei' => '',
                                'manufacturer' => '',
                                'meid' => '',
                                'model' => '',
                                'serialNumber' => ''
                ],
                'deviceMetadata' => [
                                'entries' => [
                                                                
                                ]
                ],
                'googleWorkspaceCustomerId' => '',
                'preProvisioningToken' => '',
                'sectionType' => '',
                'simlockProfileId' => ''
        ]
    ]
  ]),
  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}}/v1/partners/:partnerId/devices:claimAsync', [
  'body' => '{
  "claims": [
    {
      "customerId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      },
      "googleWorkspaceCustomerId": "",
      "preProvisioningToken": "",
      "sectionType": "",
      "simlockProfileId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'claims' => [
    [
        'customerId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ],
        'deviceMetadata' => [
                'entries' => [
                                
                ]
        ],
        'googleWorkspaceCustomerId' => '',
        'preProvisioningToken' => '',
        'sectionType' => '',
        'simlockProfileId' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'claims' => [
    [
        'customerId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ],
        'deviceMetadata' => [
                'entries' => [
                                
                ]
        ],
        'googleWorkspaceCustomerId' => '',
        'preProvisioningToken' => '',
        'sectionType' => '',
        'simlockProfileId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync');
$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}}/v1/partners/:partnerId/devices:claimAsync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "claims": [
    {
      "customerId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      },
      "googleWorkspaceCustomerId": "",
      "preProvisioningToken": "",
      "sectionType": "",
      "simlockProfileId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "claims": [
    {
      "customerId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      },
      "googleWorkspaceCustomerId": "",
      "preProvisioningToken": "",
      "sectionType": "",
      "simlockProfileId": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:claimAsync", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"

payload = { "claims": [
        {
            "customerId": "",
            "deviceIdentifier": {
                "chromeOsAttestedDeviceId": "",
                "deviceType": "",
                "imei": "",
                "manufacturer": "",
                "meid": "",
                "model": "",
                "serialNumber": ""
            },
            "deviceMetadata": { "entries": {} },
            "googleWorkspaceCustomerId": "",
            "preProvisioningToken": "",
            "sectionType": "",
            "simlockProfileId": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync"

payload <- "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync")

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  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/partners/:partnerId/devices:claimAsync') do |req|
  req.body = "{\n  \"claims\": [\n    {\n      \"customerId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      },\n      \"googleWorkspaceCustomerId\": \"\",\n      \"preProvisioningToken\": \"\",\n      \"sectionType\": \"\",\n      \"simlockProfileId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync";

    let payload = json!({"claims": (
            json!({
                "customerId": "",
                "deviceIdentifier": json!({
                    "chromeOsAttestedDeviceId": "",
                    "deviceType": "",
                    "imei": "",
                    "manufacturer": "",
                    "meid": "",
                    "model": "",
                    "serialNumber": ""
                }),
                "deviceMetadata": json!({"entries": json!({})}),
                "googleWorkspaceCustomerId": "",
                "preProvisioningToken": "",
                "sectionType": "",
                "simlockProfileId": ""
            })
        )});

    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 '{
  "claims": [
    {
      "customerId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      },
      "googleWorkspaceCustomerId": "",
      "preProvisioningToken": "",
      "sectionType": "",
      "simlockProfileId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:claimAsync \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "claims": [\n    {\n      "customerId": "",\n      "deviceIdentifier": {\n        "chromeOsAttestedDeviceId": "",\n        "deviceType": "",\n        "imei": "",\n        "manufacturer": "",\n        "meid": "",\n        "model": "",\n        "serialNumber": ""\n      },\n      "deviceMetadata": {\n        "entries": {}\n      },\n      "googleWorkspaceCustomerId": "",\n      "preProvisioningToken": "",\n      "sectionType": "",\n      "simlockProfileId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:claimAsync

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["claims": [
    [
      "customerId": "",
      "deviceIdentifier": [
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      ],
      "deviceMetadata": ["entries": []],
      "googleWorkspaceCustomerId": "",
      "preProvisioningToken": "",
      "sectionType": "",
      "simlockProfileId": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:claimAsync")! 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}}/v1/partners/:partnerId/devices:findByIdentifier");

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  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier" {:content-type :json
                                                                                            :form-params {:deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                             :deviceType ""
                                                                                                                             :imei ""
                                                                                                                             :manufacturer ""
                                                                                                                             :meid ""
                                                                                                                             :model ""
                                                                                                                             :serialNumber ""}
                                                                                                          :limit ""
                                                                                                          :pageToken ""}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\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}}/v1/partners/:partnerId/devices:findByIdentifier"),
    Content = new StringContent("{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\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}}/v1/partners/:partnerId/devices:findByIdentifier");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier"

	payload := strings.NewReader("{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\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/v1/partners/:partnerId/devices:findByIdentifier HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 219

{
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "limit": "",
  "pageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\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  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier")
  .header("content-type", "application/json")
  .body("{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  limit: '',
  pageToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier',
  headers: {'content-type': 'application/json'},
  data: {
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    limit: '',
    pageToken: ''
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"limit":"","pageToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deviceIdentifier": {\n    "chromeOsAttestedDeviceId": "",\n    "deviceType": "",\n    "imei": "",\n    "manufacturer": "",\n    "meid": "",\n    "model": "",\n    "serialNumber": ""\n  },\n  "limit": "",\n  "pageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier")
  .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/v1/partners/:partnerId/devices:findByIdentifier',
  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({
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  limit: '',
  pageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier',
  headers: {'content-type': 'application/json'},
  body: {
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    limit: '',
    pageToken: ''
  },
  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}}/v1/partners/:partnerId/devices:findByIdentifier');

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

req.type('json');
req.send({
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  limit: '',
  pageToken: ''
});

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}}/v1/partners/:partnerId/devices:findByIdentifier',
  headers: {'content-type': 'application/json'},
  data: {
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    limit: '',
    pageToken: ''
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"limit":"","pageToken":""}'
};

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 = @{ @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" },
                              @"limit": @"",
                              @"pageToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier"]
                                                       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}}/v1/partners/:partnerId/devices:findByIdentifier" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier",
  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([
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ],
    'limit' => '',
    'pageToken' => ''
  ]),
  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}}/v1/partners/:partnerId/devices:findByIdentifier', [
  'body' => '{
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "limit": "",
  "pageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deviceIdentifier' => [
    'chromeOsAttestedDeviceId' => '',
    'deviceType' => '',
    'imei' => '',
    'manufacturer' => '',
    'meid' => '',
    'model' => '',
    'serialNumber' => ''
  ],
  'limit' => '',
  'pageToken' => ''
]));

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

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

append(json_encode([
  'deviceIdentifier' => [
    'chromeOsAttestedDeviceId' => '',
    'deviceType' => '',
    'imei' => '',
    'manufacturer' => '',
    'meid' => '',
    'model' => '',
    'serialNumber' => ''
  ],
  'limit' => '',
  'pageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier');
$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}}/v1/partners/:partnerId/devices:findByIdentifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "limit": "",
  "pageToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "limit": "",
  "pageToken": ""
}'

import http.client

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

payload = "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:findByIdentifier", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier"

payload = {
    "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
    },
    "limit": "",
    "pageToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier"

payload <- "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\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}}/v1/partners/:partnerId/devices:findByIdentifier")

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  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\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/v1/partners/:partnerId/devices:findByIdentifier') do |req|
  req.body = "{\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"limit\": \"\",\n  \"pageToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier";

    let payload = json!({
        "deviceIdentifier": json!({
            "chromeOsAttestedDeviceId": "",
            "deviceType": "",
            "imei": "",
            "manufacturer": "",
            "meid": "",
            "model": "",
            "serialNumber": ""
        }),
        "limit": "",
        "pageToken": ""
    });

    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 '{
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "limit": "",
  "pageToken": ""
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "deviceIdentifier": {\n    "chromeOsAttestedDeviceId": "",\n    "deviceType": "",\n    "imei": "",\n    "manufacturer": "",\n    "meid": "",\n    "model": "",\n    "serialNumber": ""\n  },\n  "limit": "",\n  "pageToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "deviceIdentifier": [
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  ],
  "limit": "",
  "pageToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:findByIdentifier")! 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}}/v1/partners/:partnerId/devices:findByOwner");

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  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner" {:content-type :json
                                                                                       :form-params {:customerId []
                                                                                                     :googleWorkspaceCustomerId []
                                                                                                     :limit ""
                                                                                                     :pageToken ""
                                                                                                     :sectionType ""}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\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}}/v1/partners/:partnerId/devices:findByOwner"),
    Content = new StringContent("{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\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}}/v1/partners/:partnerId/devices:findByOwner");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner"

	payload := strings.NewReader("{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\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/v1/partners/:partnerId/devices:findByOwner HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "customerId": [],
  "googleWorkspaceCustomerId": [],
  "limit": "",
  "pageToken": "",
  "sectionType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\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  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner")
  .header("content-type", "application/json")
  .body("{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  customerId: [],
  googleWorkspaceCustomerId: [],
  limit: '',
  pageToken: '',
  sectionType: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner',
  headers: {'content-type': 'application/json'},
  data: {
    customerId: [],
    googleWorkspaceCustomerId: [],
    limit: '',
    pageToken: '',
    sectionType: ''
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customerId":[],"googleWorkspaceCustomerId":[],"limit":"","pageToken":"","sectionType":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "customerId": [],\n  "googleWorkspaceCustomerId": [],\n  "limit": "",\n  "pageToken": "",\n  "sectionType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner")
  .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/v1/partners/:partnerId/devices:findByOwner',
  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({
  customerId: [],
  googleWorkspaceCustomerId: [],
  limit: '',
  pageToken: '',
  sectionType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner',
  headers: {'content-type': 'application/json'},
  body: {
    customerId: [],
    googleWorkspaceCustomerId: [],
    limit: '',
    pageToken: '',
    sectionType: ''
  },
  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}}/v1/partners/:partnerId/devices:findByOwner');

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

req.type('json');
req.send({
  customerId: [],
  googleWorkspaceCustomerId: [],
  limit: '',
  pageToken: '',
  sectionType: ''
});

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}}/v1/partners/:partnerId/devices:findByOwner',
  headers: {'content-type': 'application/json'},
  data: {
    customerId: [],
    googleWorkspaceCustomerId: [],
    limit: '',
    pageToken: '',
    sectionType: ''
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"customerId":[],"googleWorkspaceCustomerId":[],"limit":"","pageToken":"","sectionType":""}'
};

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 = @{ @"customerId": @[  ],
                              @"googleWorkspaceCustomerId": @[  ],
                              @"limit": @"",
                              @"pageToken": @"",
                              @"sectionType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner"]
                                                       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}}/v1/partners/:partnerId/devices:findByOwner" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner",
  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([
    'customerId' => [
        
    ],
    'googleWorkspaceCustomerId' => [
        
    ],
    'limit' => '',
    'pageToken' => '',
    'sectionType' => ''
  ]),
  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}}/v1/partners/:partnerId/devices:findByOwner', [
  'body' => '{
  "customerId": [],
  "googleWorkspaceCustomerId": [],
  "limit": "",
  "pageToken": "",
  "sectionType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'customerId' => [
    
  ],
  'googleWorkspaceCustomerId' => [
    
  ],
  'limit' => '',
  'pageToken' => '',
  'sectionType' => ''
]));

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

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

append(json_encode([
  'customerId' => [
    
  ],
  'googleWorkspaceCustomerId' => [
    
  ],
  'limit' => '',
  'pageToken' => '',
  'sectionType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner');
$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}}/v1/partners/:partnerId/devices:findByOwner' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customerId": [],
  "googleWorkspaceCustomerId": [],
  "limit": "",
  "pageToken": "",
  "sectionType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "customerId": [],
  "googleWorkspaceCustomerId": [],
  "limit": "",
  "pageToken": "",
  "sectionType": ""
}'

import http.client

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

payload = "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:findByOwner", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner"

payload = {
    "customerId": [],
    "googleWorkspaceCustomerId": [],
    "limit": "",
    "pageToken": "",
    "sectionType": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner"

payload <- "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\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}}/v1/partners/:partnerId/devices:findByOwner")

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  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\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/v1/partners/:partnerId/devices:findByOwner') do |req|
  req.body = "{\n  \"customerId\": [],\n  \"googleWorkspaceCustomerId\": [],\n  \"limit\": \"\",\n  \"pageToken\": \"\",\n  \"sectionType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner";

    let payload = json!({
        "customerId": (),
        "googleWorkspaceCustomerId": (),
        "limit": "",
        "pageToken": "",
        "sectionType": ""
    });

    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 '{
  "customerId": [],
  "googleWorkspaceCustomerId": [],
  "limit": "",
  "pageToken": "",
  "sectionType": ""
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:findByOwner \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "customerId": [],\n  "googleWorkspaceCustomerId": [],\n  "limit": "",\n  "pageToken": "",\n  "sectionType": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:findByOwner

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "customerId": [],
  "googleWorkspaceCustomerId": [],
  "limit": "",
  "pageToken": "",
  "sectionType": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:findByOwner")! 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}}/v1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/: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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata");

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  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata" {:content-type :json
                                                                                                    :form-params {:deviceMetadata {:entries {}}}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deviceMetadata\": {\n    \"entries\": {}\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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"),
    Content = new StringContent("{\n  \"deviceMetadata\": {\n    \"entries\": {}\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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"

	payload := strings.NewReader("{\n  \"deviceMetadata\": {\n    \"entries\": {}\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/v1/partners/:metadataOwnerId/devices/:deviceId/metadata HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "deviceMetadata": {
    "entries": {}
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deviceMetadata\": {\n    \"entries\": {}\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  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata")
  .header("content-type", "application/json")
  .body("{\n  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}")
  .asString();

const data = JSON.stringify({
  deviceMetadata: {
    entries: {}
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata',
  headers: {'content-type': 'application/json'},
  data: {deviceMetadata: {entries: {}}}
};

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

const url = '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deviceMetadata":{"entries":{}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deviceMetadata": {\n    "entries": {}\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  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata")
  .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/v1/partners/:metadataOwnerId/devices/:deviceId/metadata',
  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({deviceMetadata: {entries: {}}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata',
  headers: {'content-type': 'application/json'},
  body: {deviceMetadata: {entries: {}}},
  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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata');

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

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

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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata',
  headers: {'content-type': 'application/json'},
  data: {deviceMetadata: {entries: {}}}
};

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

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

const url = '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deviceMetadata":{"entries":{}}}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"]
                                                       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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}" in

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

 "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata",
  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([
    'deviceMetadata' => [
        'entries' => [
                
        ]
    ]
  ]),
  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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata', [
  'body' => '{
  "deviceMetadata": {
    "entries": {}
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'deviceMetadata' => [
    'entries' => [
        
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata');
$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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deviceMetadata": {
    "entries": {}
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deviceMetadata": {
    "entries": {}
  }
}'

import http.client

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

payload = "{\n  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:metadataOwnerId/devices/:deviceId/metadata", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata"

payload <- "{\n  \"deviceMetadata\": {\n    \"entries\": {}\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}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata")

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  \"deviceMetadata\": {\n    \"entries\": {}\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/v1/partners/:metadataOwnerId/devices/:deviceId/metadata') do |req|
  req.body = "{\n  \"deviceMetadata\": {\n    \"entries\": {}\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata";

    let payload = json!({"deviceMetadata": json!({"entries": 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 '{
  "deviceMetadata": {
    "entries": {}
  }
}' |  \
  http POST {{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "deviceMetadata": {\n    "entries": {}\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:metadataOwnerId/devices/:deviceId/metadata")! 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}}/v1/partners/:partnerId/devices:unclaim");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim" {:content-type :json
                                                                                   :form-params {:deviceId ""
                                                                                                 :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                    :deviceType ""
                                                                                                                    :imei ""
                                                                                                                    :manufacturer ""
                                                                                                                    :meid ""
                                                                                                                    :model ""
                                                                                                                    :serialNumber ""}
                                                                                                 :sectionType ""
                                                                                                 :vacationModeDays 0
                                                                                                 :vacationModeExpireTime ""}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\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}}/v1/partners/:partnerId/devices:unclaim"),
    Content = new StringContent("{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\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}}/v1/partners/:partnerId/devices:unclaim");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim"

	payload := strings.NewReader("{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\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/v1/partners/:partnerId/devices:unclaim HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 281

{
  "deviceId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "sectionType": "",
  "vacationModeDays": 0,
  "vacationModeExpireTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:unclaim"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:unclaim")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:unclaim")
  .header("content-type", "application/json")
  .body("{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deviceId: '',
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  sectionType: '',
  vacationModeDays: 0,
  vacationModeExpireTime: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim',
  headers: {'content-type': 'application/json'},
  data: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    sectionType: '',
    vacationModeDays: 0,
    vacationModeExpireTime: ''
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"sectionType":"","vacationModeDays":0,"vacationModeExpireTime":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deviceId": "",\n  "deviceIdentifier": {\n    "chromeOsAttestedDeviceId": "",\n    "deviceType": "",\n    "imei": "",\n    "manufacturer": "",\n    "meid": "",\n    "model": "",\n    "serialNumber": ""\n  },\n  "sectionType": "",\n  "vacationModeDays": 0,\n  "vacationModeExpireTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:unclaim")
  .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/v1/partners/:partnerId/devices:unclaim',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  deviceId: '',
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  sectionType: '',
  vacationModeDays: 0,
  vacationModeExpireTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim',
  headers: {'content-type': 'application/json'},
  body: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    sectionType: '',
    vacationModeDays: 0,
    vacationModeExpireTime: ''
  },
  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}}/v1/partners/:partnerId/devices:unclaim');

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

req.type('json');
req.send({
  deviceId: '',
  deviceIdentifier: {
    chromeOsAttestedDeviceId: '',
    deviceType: '',
    imei: '',
    manufacturer: '',
    meid: '',
    model: '',
    serialNumber: ''
  },
  sectionType: '',
  vacationModeDays: 0,
  vacationModeExpireTime: ''
});

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}}/v1/partners/:partnerId/devices:unclaim',
  headers: {'content-type': 'application/json'},
  data: {
    deviceId: '',
    deviceIdentifier: {
      chromeOsAttestedDeviceId: '',
      deviceType: '',
      imei: '',
      manufacturer: '',
      meid: '',
      model: '',
      serialNumber: ''
    },
    sectionType: '',
    vacationModeDays: 0,
    vacationModeExpireTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"sectionType":"","vacationModeDays":0,"vacationModeExpireTime":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"deviceId": @"",
                              @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" },
                              @"sectionType": @"",
                              @"vacationModeDays": @0,
                              @"vacationModeExpireTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:unclaim"]
                                                       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}}/v1/partners/:partnerId/devices:unclaim" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim",
  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([
    'deviceId' => '',
    'deviceIdentifier' => [
        'chromeOsAttestedDeviceId' => '',
        'deviceType' => '',
        'imei' => '',
        'manufacturer' => '',
        'meid' => '',
        'model' => '',
        'serialNumber' => ''
    ],
    'sectionType' => '',
    'vacationModeDays' => 0,
    'vacationModeExpireTime' => ''
  ]),
  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}}/v1/partners/:partnerId/devices:unclaim', [
  'body' => '{
  "deviceId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "sectionType": "",
  "vacationModeDays": 0,
  "vacationModeExpireTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:unclaim');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deviceId' => '',
  'deviceIdentifier' => [
    'chromeOsAttestedDeviceId' => '',
    'deviceType' => '',
    'imei' => '',
    'manufacturer' => '',
    'meid' => '',
    'model' => '',
    'serialNumber' => ''
  ],
  'sectionType' => '',
  'vacationModeDays' => 0,
  'vacationModeExpireTime' => ''
]));

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

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

append(json_encode([
  'deviceId' => '',
  'deviceIdentifier' => [
    'chromeOsAttestedDeviceId' => '',
    'deviceType' => '',
    'imei' => '',
    'manufacturer' => '',
    'meid' => '',
    'model' => '',
    'serialNumber' => ''
  ],
  'sectionType' => '',
  'vacationModeDays' => 0,
  'vacationModeExpireTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:unclaim');
$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}}/v1/partners/:partnerId/devices:unclaim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deviceId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "sectionType": "",
  "vacationModeDays": 0,
  "vacationModeExpireTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:unclaim' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deviceId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "sectionType": "",
  "vacationModeDays": 0,
  "vacationModeExpireTime": ""
}'

import http.client

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

payload = "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:unclaim", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim"

payload = {
    "deviceId": "",
    "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
    },
    "sectionType": "",
    "vacationModeDays": 0,
    "vacationModeExpireTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim"

payload <- "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\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}}/v1/partners/:partnerId/devices:unclaim")

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  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\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/v1/partners/:partnerId/devices:unclaim') do |req|
  req.body = "{\n  \"deviceId\": \"\",\n  \"deviceIdentifier\": {\n    \"chromeOsAttestedDeviceId\": \"\",\n    \"deviceType\": \"\",\n    \"imei\": \"\",\n    \"manufacturer\": \"\",\n    \"meid\": \"\",\n    \"model\": \"\",\n    \"serialNumber\": \"\"\n  },\n  \"sectionType\": \"\",\n  \"vacationModeDays\": 0,\n  \"vacationModeExpireTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim";

    let payload = json!({
        "deviceId": "",
        "deviceIdentifier": json!({
            "chromeOsAttestedDeviceId": "",
            "deviceType": "",
            "imei": "",
            "manufacturer": "",
            "meid": "",
            "model": "",
            "serialNumber": ""
        }),
        "sectionType": "",
        "vacationModeDays": 0,
        "vacationModeExpireTime": ""
    });

    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 '{
  "deviceId": "",
  "deviceIdentifier": {
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  },
  "sectionType": "",
  "vacationModeDays": 0,
  "vacationModeExpireTime": ""
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:unclaim \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "deviceId": "",\n  "deviceIdentifier": {\n    "chromeOsAttestedDeviceId": "",\n    "deviceType": "",\n    "imei": "",\n    "manufacturer": "",\n    "meid": "",\n    "model": "",\n    "serialNumber": ""\n  },\n  "sectionType": "",\n  "vacationModeDays": 0,\n  "vacationModeExpireTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:unclaim

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "deviceId": "",
  "deviceIdentifier": [
    "chromeOsAttestedDeviceId": "",
    "deviceType": "",
    "imei": "",
    "manufacturer": "",
    "meid": "",
    "model": "",
    "serialNumber": ""
  ],
  "sectionType": "",
  "vacationModeDays": 0,
  "vacationModeExpireTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:unclaim")! 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}}/v1/partners/:partnerId/devices:unclaimAsync");

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  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync" {:content-type :json
                                                                                        :form-params {:unclaims [{:deviceId ""
                                                                                                                  :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                                     :deviceType ""
                                                                                                                                     :imei ""
                                                                                                                                     :manufacturer ""
                                                                                                                                     :meid ""
                                                                                                                                     :model ""
                                                                                                                                     :serialNumber ""}
                                                                                                                  :sectionType ""
                                                                                                                  :vacationModeDays 0
                                                                                                                  :vacationModeExpireTime ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"),
    Content = new StringContent("{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"

	payload := strings.NewReader("{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/partners/:partnerId/devices:unclaimAsync HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 365

{
  "unclaims": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "sectionType": "",
      "vacationModeDays": 0,
      "vacationModeExpireTime": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync")
  .header("content-type", "application/json")
  .body("{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  unclaims: [
    {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      sectionType: '',
      vacationModeDays: 0,
      vacationModeExpireTime: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync',
  headers: {'content-type': 'application/json'},
  data: {
    unclaims: [
      {
        deviceId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        sectionType: '',
        vacationModeDays: 0,
        vacationModeExpireTime: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"unclaims":[{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"sectionType":"","vacationModeDays":0,"vacationModeExpireTime":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "unclaims": [\n    {\n      "deviceId": "",\n      "deviceIdentifier": {\n        "chromeOsAttestedDeviceId": "",\n        "deviceType": "",\n        "imei": "",\n        "manufacturer": "",\n        "meid": "",\n        "model": "",\n        "serialNumber": ""\n      },\n      "sectionType": "",\n      "vacationModeDays": 0,\n      "vacationModeExpireTime": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync")
  .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/v1/partners/:partnerId/devices:unclaimAsync',
  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({
  unclaims: [
    {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      sectionType: '',
      vacationModeDays: 0,
      vacationModeExpireTime: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync',
  headers: {'content-type': 'application/json'},
  body: {
    unclaims: [
      {
        deviceId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        sectionType: '',
        vacationModeDays: 0,
        vacationModeExpireTime: ''
      }
    ]
  },
  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}}/v1/partners/:partnerId/devices:unclaimAsync');

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

req.type('json');
req.send({
  unclaims: [
    {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      sectionType: '',
      vacationModeDays: 0,
      vacationModeExpireTime: ''
    }
  ]
});

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}}/v1/partners/:partnerId/devices:unclaimAsync',
  headers: {'content-type': 'application/json'},
  data: {
    unclaims: [
      {
        deviceId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        sectionType: '',
        vacationModeDays: 0,
        vacationModeExpireTime: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"unclaims":[{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"sectionType":"","vacationModeDays":0,"vacationModeExpireTime":""}]}'
};

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 = @{ @"unclaims": @[ @{ @"deviceId": @"", @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" }, @"sectionType": @"", @"vacationModeDays": @0, @"vacationModeExpireTime": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"]
                                                       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}}/v1/partners/:partnerId/devices:unclaimAsync" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync",
  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([
    'unclaims' => [
        [
                'deviceId' => '',
                'deviceIdentifier' => [
                                'chromeOsAttestedDeviceId' => '',
                                'deviceType' => '',
                                'imei' => '',
                                'manufacturer' => '',
                                'meid' => '',
                                'model' => '',
                                'serialNumber' => ''
                ],
                'sectionType' => '',
                'vacationModeDays' => 0,
                'vacationModeExpireTime' => ''
        ]
    ]
  ]),
  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}}/v1/partners/:partnerId/devices:unclaimAsync', [
  'body' => '{
  "unclaims": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "sectionType": "",
      "vacationModeDays": 0,
      "vacationModeExpireTime": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'unclaims' => [
    [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ],
        'sectionType' => '',
        'vacationModeDays' => 0,
        'vacationModeExpireTime' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'unclaims' => [
    [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ],
        'sectionType' => '',
        'vacationModeDays' => 0,
        'vacationModeExpireTime' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync');
$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}}/v1/partners/:partnerId/devices:unclaimAsync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "unclaims": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "sectionType": "",
      "vacationModeDays": 0,
      "vacationModeExpireTime": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "unclaims": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "sectionType": "",
      "vacationModeDays": 0,
      "vacationModeExpireTime": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:unclaimAsync", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"

payload = { "unclaims": [
        {
            "deviceId": "",
            "deviceIdentifier": {
                "chromeOsAttestedDeviceId": "",
                "deviceType": "",
                "imei": "",
                "manufacturer": "",
                "meid": "",
                "model": "",
                "serialNumber": ""
            },
            "sectionType": "",
            "vacationModeDays": 0,
            "vacationModeExpireTime": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync"

payload <- "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync")

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  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/partners/:partnerId/devices:unclaimAsync') do |req|
  req.body = "{\n  \"unclaims\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"sectionType\": \"\",\n      \"vacationModeDays\": 0,\n      \"vacationModeExpireTime\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync";

    let payload = json!({"unclaims": (
            json!({
                "deviceId": "",
                "deviceIdentifier": json!({
                    "chromeOsAttestedDeviceId": "",
                    "deviceType": "",
                    "imei": "",
                    "manufacturer": "",
                    "meid": "",
                    "model": "",
                    "serialNumber": ""
                }),
                "sectionType": "",
                "vacationModeDays": 0,
                "vacationModeExpireTime": ""
            })
        )});

    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 '{
  "unclaims": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "sectionType": "",
      "vacationModeDays": 0,
      "vacationModeExpireTime": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "unclaims": [\n    {\n      "deviceId": "",\n      "deviceIdentifier": {\n        "chromeOsAttestedDeviceId": "",\n        "deviceType": "",\n        "imei": "",\n        "manufacturer": "",\n        "meid": "",\n        "model": "",\n        "serialNumber": ""\n      },\n      "sectionType": "",\n      "vacationModeDays": 0,\n      "vacationModeExpireTime": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["unclaims": [
    [
      "deviceId": "",
      "deviceIdentifier": [
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      ],
      "sectionType": "",
      "vacationModeDays": 0,
      "vacationModeExpireTime": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:unclaimAsync")! 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}}/v1/partners/:partnerId/devices:updateMetadataAsync");

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  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync" {:content-type :json
                                                                                               :form-params {:updates [{:deviceId ""
                                                                                                                        :deviceIdentifier {:chromeOsAttestedDeviceId ""
                                                                                                                                           :deviceType ""
                                                                                                                                           :imei ""
                                                                                                                                           :manufacturer ""
                                                                                                                                           :meid ""
                                                                                                                                           :model ""
                                                                                                                                           :serialNumber ""}
                                                                                                                        :deviceMetadata {:entries {}}}]}})

require "http/client"

url = "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"),
    Content = new StringContent("{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"

	payload := strings.NewReader("{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/partners/:partnerId/devices:updateMetadataAsync HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 331

{
  "updates": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      }
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync")
  .header("content-type", "application/json")
  .body("{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  updates: [
    {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      deviceMetadata: {
        entries: {}
      }
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync',
  headers: {'content-type': 'application/json'},
  data: {
    updates: [
      {
        deviceId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        deviceMetadata: {entries: {}}
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"updates":[{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"deviceMetadata":{"entries":{}}}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "updates": [\n    {\n      "deviceId": "",\n      "deviceIdentifier": {\n        "chromeOsAttestedDeviceId": "",\n        "deviceType": "",\n        "imei": "",\n        "manufacturer": "",\n        "meid": "",\n        "model": "",\n        "serialNumber": ""\n      },\n      "deviceMetadata": {\n        "entries": {}\n      }\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync")
  .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/v1/partners/:partnerId/devices:updateMetadataAsync',
  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({
  updates: [
    {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      deviceMetadata: {entries: {}}
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync',
  headers: {'content-type': 'application/json'},
  body: {
    updates: [
      {
        deviceId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        deviceMetadata: {entries: {}}
      }
    ]
  },
  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}}/v1/partners/:partnerId/devices:updateMetadataAsync');

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

req.type('json');
req.send({
  updates: [
    {
      deviceId: '',
      deviceIdentifier: {
        chromeOsAttestedDeviceId: '',
        deviceType: '',
        imei: '',
        manufacturer: '',
        meid: '',
        model: '',
        serialNumber: ''
      },
      deviceMetadata: {
        entries: {}
      }
    }
  ]
});

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}}/v1/partners/:partnerId/devices:updateMetadataAsync',
  headers: {'content-type': 'application/json'},
  data: {
    updates: [
      {
        deviceId: '',
        deviceIdentifier: {
          chromeOsAttestedDeviceId: '',
          deviceType: '',
          imei: '',
          manufacturer: '',
          meid: '',
          model: '',
          serialNumber: ''
        },
        deviceMetadata: {entries: {}}
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"updates":[{"deviceId":"","deviceIdentifier":{"chromeOsAttestedDeviceId":"","deviceType":"","imei":"","manufacturer":"","meid":"","model":"","serialNumber":""},"deviceMetadata":{"entries":{}}}]}'
};

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 = @{ @"updates": @[ @{ @"deviceId": @"", @"deviceIdentifier": @{ @"chromeOsAttestedDeviceId": @"", @"deviceType": @"", @"imei": @"", @"manufacturer": @"", @"meid": @"", @"model": @"", @"serialNumber": @"" }, @"deviceMetadata": @{ @"entries": @{  } } } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"]
                                                       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}}/v1/partners/:partnerId/devices:updateMetadataAsync" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync",
  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([
    'updates' => [
        [
                'deviceId' => '',
                'deviceIdentifier' => [
                                'chromeOsAttestedDeviceId' => '',
                                'deviceType' => '',
                                'imei' => '',
                                'manufacturer' => '',
                                'meid' => '',
                                'model' => '',
                                'serialNumber' => ''
                ],
                'deviceMetadata' => [
                                'entries' => [
                                                                
                                ]
                ]
        ]
    ]
  ]),
  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}}/v1/partners/:partnerId/devices:updateMetadataAsync', [
  'body' => '{
  "updates": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      }
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'updates' => [
    [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ],
        'deviceMetadata' => [
                'entries' => [
                                
                ]
        ]
    ]
  ]
]));

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

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

append(json_encode([
  'updates' => [
    [
        'deviceId' => '',
        'deviceIdentifier' => [
                'chromeOsAttestedDeviceId' => '',
                'deviceType' => '',
                'imei' => '',
                'manufacturer' => '',
                'meid' => '',
                'model' => '',
                'serialNumber' => ''
        ],
        'deviceMetadata' => [
                'entries' => [
                                
                ]
        ]
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync');
$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}}/v1/partners/:partnerId/devices:updateMetadataAsync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "updates": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      }
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "updates": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      }
    }
  ]
}'

import http.client

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

payload = "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/partners/:partnerId/devices:updateMetadataAsync", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"

payload = { "updates": [
        {
            "deviceId": "",
            "deviceIdentifier": {
                "chromeOsAttestedDeviceId": "",
                "deviceType": "",
                "imei": "",
                "manufacturer": "",
                "meid": "",
                "model": "",
                "serialNumber": ""
            },
            "deviceMetadata": { "entries": {} }
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync"

payload <- "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync")

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  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/partners/:partnerId/devices:updateMetadataAsync') do |req|
  req.body = "{\n  \"updates\": [\n    {\n      \"deviceId\": \"\",\n      \"deviceIdentifier\": {\n        \"chromeOsAttestedDeviceId\": \"\",\n        \"deviceType\": \"\",\n        \"imei\": \"\",\n        \"manufacturer\": \"\",\n        \"meid\": \"\",\n        \"model\": \"\",\n        \"serialNumber\": \"\"\n      },\n      \"deviceMetadata\": {\n        \"entries\": {}\n      }\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync";

    let payload = json!({"updates": (
            json!({
                "deviceId": "",
                "deviceIdentifier": json!({
                    "chromeOsAttestedDeviceId": "",
                    "deviceType": "",
                    "imei": "",
                    "manufacturer": "",
                    "meid": "",
                    "model": "",
                    "serialNumber": ""
                }),
                "deviceMetadata": json!({"entries": 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 '{
  "updates": [
    {
      "deviceId": "",
      "deviceIdentifier": {
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      },
      "deviceMetadata": {
        "entries": {}
      }
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "updates": [\n    {\n      "deviceId": "",\n      "deviceIdentifier": {\n        "chromeOsAttestedDeviceId": "",\n        "deviceType": "",\n        "imei": "",\n        "manufacturer": "",\n        "meid": "",\n        "model": "",\n        "serialNumber": ""\n      },\n      "deviceMetadata": {\n        "entries": {}\n      }\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["updates": [
    [
      "deviceId": "",
      "deviceIdentifier": [
        "chromeOsAttestedDeviceId": "",
        "deviceType": "",
        "imei": "",
        "manufacturer": "",
        "meid": "",
        "model": "",
        "serialNumber": ""
      ],
      "deviceMetadata": ["entries": []]
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/partners/:partnerId/devices:updateMetadataAsync")! 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}}/v1/:parent/customers");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/:parent/customers")

require "http/client"

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

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

package main

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

func main() {

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/:parent/customers")

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

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

import requests

url = "{{baseUrl}}/v1/:parent/customers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/customers"

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

content(response, "text")

require 'uri'
require 'net/http'

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

puts response.status
puts response.body

use reqwest;

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

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/:parent/customers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:parent/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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:parent/vendors");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/:parent/vendors")

require "http/client"

url = "{{baseUrl}}/v1/:parent/vendors"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/:parent/vendors"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:parent/vendors'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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}}/v1/:parent/vendors'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/:parent/vendors")

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

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

import requests

url = "{{baseUrl}}/v1/:parent/vendors"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/:parent/vendors"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:parent/vendors")

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v1/:parent/vendors

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/:parent/vendors

import Foundation

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