AWS Greengrassv2017-06-07

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/groups/:GroupId/role");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/greengrass/groups/:GroupId/role" {:content-type :json
                                                                           :form-params {:RoleArn ""}})

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/role"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RoleArn\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/greengrass/groups/:GroupId/role"),
    Content = new StringContent("{\n  \"RoleArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/role");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RoleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/role"

	payload := strings.NewReader("{\n  \"RoleArn\": \"\"\n}")

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

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

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

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

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

}

PUT /baseUrl/greengrass/groups/:GroupId/role HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "RoleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/greengrass/groups/:GroupId/role")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RoleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/role"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"RoleArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"RoleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .header("content-type", "application/json")
  .body("{\n  \"RoleArn\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/greengrass/groups/:GroupId/role');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role',
  headers: {'content-type': 'application/json'},
  data: {RoleArn: ''}
};

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/role';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RoleArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RoleArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RoleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/role',
  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({RoleArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role',
  headers: {'content-type': 'application/json'},
  body: {RoleArn: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/greengrass/groups/:GroupId/role');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role',
  headers: {'content-type': 'application/json'},
  data: {RoleArn: ''}
};

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

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/role';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RoleArn":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"RoleArn": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/greengrass/groups/:GroupId/role" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RoleArn\": \"\"\n}" in

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

 "{{baseUrl}}/greengrass/groups/:GroupId/role",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'RoleArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/greengrass/groups/:GroupId/role', [
  'body' => '{
  "RoleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/role');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'RoleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/role');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/role' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RoleArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/role' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RoleArn": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/greengrass/groups/:GroupId/role", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/role"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/role"

payload <- "{\n  \"RoleArn\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/role")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"RoleArn\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/greengrass/groups/:GroupId/role') do |req|
  req.body = "{\n  \"RoleArn\": \"\"\n}"
end

puts response.status
puts response.body

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

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

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

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

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

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

    dbg!(results);
}

echo '{
  "RoleArn": ""
}' |  \
  http PUT {{baseUrl}}/greengrass/groups/:GroupId/role \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "RoleArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/role

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/servicerole");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/greengrass/servicerole" {:content-type :json
                                                                  :form-params {:RoleArn ""}})

require "http/client"

url = "{{baseUrl}}/greengrass/servicerole"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RoleArn\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/greengrass/servicerole"),
    Content = new StringContent("{\n  \"RoleArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/servicerole");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RoleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/servicerole"

	payload := strings.NewReader("{\n  \"RoleArn\": \"\"\n}")

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

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

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

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

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

}

PUT /baseUrl/greengrass/servicerole HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "RoleArn": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/servicerole"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"RoleArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"RoleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/servicerole")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/greengrass/servicerole")
  .header("content-type", "application/json")
  .body("{\n  \"RoleArn\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/greengrass/servicerole');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/greengrass/servicerole',
  headers: {'content-type': 'application/json'},
  data: {RoleArn: ''}
};

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

const url = '{{baseUrl}}/greengrass/servicerole';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RoleArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/servicerole',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RoleArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RoleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/servicerole")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/servicerole',
  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({RoleArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/greengrass/servicerole',
  headers: {'content-type': 'application/json'},
  body: {RoleArn: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/greengrass/servicerole');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/greengrass/servicerole',
  headers: {'content-type': 'application/json'},
  data: {RoleArn: ''}
};

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

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

const url = '{{baseUrl}}/greengrass/servicerole';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RoleArn":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"RoleArn": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/greengrass/servicerole" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RoleArn\": \"\"\n}" in

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

 "{{baseUrl}}/greengrass/servicerole",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'RoleArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/greengrass/servicerole', [
  'body' => '{
  "RoleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/servicerole');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'RoleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/servicerole');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/servicerole' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RoleArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/servicerole' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RoleArn": ""
}'

import http.client

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

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

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

conn.request("PUT", "/baseUrl/greengrass/servicerole", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/servicerole"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/servicerole"

payload <- "{\n  \"RoleArn\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/servicerole")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"RoleArn\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/greengrass/servicerole') do |req|
  req.body = "{\n  \"RoleArn\": \"\"\n}"
end

puts response.status
puts response.body

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

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

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

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

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

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

    dbg!(results);
}

echo '{
  "RoleArn": ""
}' |  \
  http PUT {{baseUrl}}/greengrass/servicerole \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "RoleArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/servicerole

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/connectors");

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  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/connectors" {:content-type :json
                                                                             :form-params {:InitialVersion {:Connectors ""}
                                                                                           :Name ""
                                                                                           :tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/connectors"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/connectors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "InitialVersion": {
    "Connectors": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/connectors")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/connectors")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    Connectors: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/connectors',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Connectors: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Connectors":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/connectors',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "Connectors": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/connectors")
  .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/greengrass/definition/connectors',
  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({InitialVersion: {Connectors: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/connectors',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {Connectors: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/connectors');

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

req.type('json');
req.send({
  InitialVersion: {
    Connectors: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/connectors',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Connectors: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Connectors":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"Connectors": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/connectors"]
                                                       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}}/greengrass/definition/connectors" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/connectors",
  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([
    'InitialVersion' => [
        'Connectors' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/connectors', [
  'body' => '{
  "InitialVersion": {
    "Connectors": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/connectors');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'Connectors' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'Connectors' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/connectors');
$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}}/greengrass/definition/connectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Connectors": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/connectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Connectors": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/connectors", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/connectors"

payload = {
    "InitialVersion": { "Connectors": "" },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/connectors"

payload <- "{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/connectors")

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  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/connectors') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"Connectors\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({"Connectors": ""}),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "Connectors": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/connectors \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "Connectors": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/connectors

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": ["Connectors": ""],
  "Name": "",
  "tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/connectors")! 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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions");

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  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions" {:content-type :json
                                                                                                             :form-params {:Connectors [{:ConnectorArn ""
                                                                                                                                         :Id ""
                                                                                                                                         :Parameters ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"),
    Content = new StringContent("{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"

	payload := strings.NewReader("{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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/greengrass/definition/connectors/:ConnectorDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "Connectors": [
    {
      "ConnectorArn": "",
      "Id": "",
      "Parameters": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Connectors: [
    {
      ConnectorArn: '',
      Id: '',
      Parameters: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Connectors: [{ConnectorArn: '', Id: '', Parameters: ''}]}
};

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

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Connectors":[{"ConnectorArn":"","Id":"","Parameters":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Connectors": [\n    {\n      "ConnectorArn": "",\n      "Id": "",\n      "Parameters": ""\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  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions")
  .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/greengrass/definition/connectors/:ConnectorDefinitionId/versions',
  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({Connectors: [{ConnectorArn: '', Id: '', Parameters: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {Connectors: [{ConnectorArn: '', Id: '', Parameters: ''}]},
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions');

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

req.type('json');
req.send({
  Connectors: [
    {
      ConnectorArn: '',
      Id: '',
      Parameters: ''
    }
  ]
});

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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Connectors: [{ConnectorArn: '', Id: '', Parameters: ''}]}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Connectors":[{"ConnectorArn":"","Id":"","Parameters":""}]}'
};

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 = @{ @"Connectors": @[ @{ @"ConnectorArn": @"", @"Id": @"", @"Parameters": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"]
                                                       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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions",
  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([
    'Connectors' => [
        [
                'ConnectorArn' => '',
                'Id' => '',
                'Parameters' => ''
        ]
    ]
  ]),
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions', [
  'body' => '{
  "Connectors": [
    {
      "ConnectorArn": "",
      "Id": "",
      "Parameters": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Connectors' => [
    [
        'ConnectorArn' => '',
        'Id' => '',
        'Parameters' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Connectors' => [
    [
        'ConnectorArn' => '',
        'Id' => '',
        'Parameters' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions');
$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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Connectors": [
    {
      "ConnectorArn": "",
      "Id": "",
      "Parameters": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Connectors": [
    {
      "ConnectorArn": "",
      "Id": "",
      "Parameters": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"

payload = { "Connectors": [
        {
            "ConnectorArn": "",
            "Id": "",
            "Parameters": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions"

payload <- "{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions")

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  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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/greengrass/definition/connectors/:ConnectorDefinitionId/versions') do |req|
  req.body = "{\n  \"Connectors\": [\n    {\n      \"ConnectorArn\": \"\",\n      \"Id\": \"\",\n      \"Parameters\": \"\"\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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions";

    let payload = json!({"Connectors": (
            json!({
                "ConnectorArn": "",
                "Id": "",
                "Parameters": ""
            })
        )});

    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 '{
  "Connectors": [
    {
      "ConnectorArn": "",
      "Id": "",
      "Parameters": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Connectors": [\n    {\n      "ConnectorArn": "",\n      "Id": "",\n      "Parameters": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Connectors": [
    [
      "ConnectorArn": "",
      "Id": "",
      "Parameters": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions")! 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}}/greengrass/definition/cores");

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  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/cores" {:content-type :json
                                                                        :form-params {:InitialVersion {:Cores ""}
                                                                                      :Name ""
                                                                                      :tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/cores"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/cores HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 73

{
  "InitialVersion": {
    "Cores": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/cores")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/cores")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    Cores: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/cores',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Cores: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/cores';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Cores":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/cores',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "Cores": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/cores")
  .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/greengrass/definition/cores',
  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({InitialVersion: {Cores: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/cores',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {Cores: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/cores');

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

req.type('json');
req.send({
  InitialVersion: {
    Cores: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/cores',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Cores: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/cores';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Cores":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"Cores": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/cores"]
                                                       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}}/greengrass/definition/cores" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/cores",
  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([
    'InitialVersion' => [
        'Cores' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/cores', [
  'body' => '{
  "InitialVersion": {
    "Cores": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/cores');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'Cores' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'Cores' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/cores');
$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}}/greengrass/definition/cores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Cores": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/cores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Cores": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/cores", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/cores"

payload = {
    "InitialVersion": { "Cores": "" },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/cores"

payload <- "{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/cores")

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  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/cores') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"Cores\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({"Cores": ""}),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "Cores": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/cores \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "Cores": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/cores

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": ["Cores": ""],
  "Name": "",
  "tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/cores")! 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}}/greengrass/definition/cores/:CoreDefinitionId/versions");

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  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions" {:content-type :json
                                                                                                   :form-params {:Cores [{:CertificateArn ""
                                                                                                                          :Id ""
                                                                                                                          :SyncShadow ""
                                                                                                                          :ThingArn ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/cores/:CoreDefinitionId/versions"),
    Content = new StringContent("{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/cores/:CoreDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions"

	payload := strings.NewReader("{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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/greengrass/definition/cores/:CoreDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 121

{
  "Cores": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Cores: [
    {
      CertificateArn: '',
      Id: '',
      SyncShadow: '',
      ThingArn: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Cores: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]}
};

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

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Cores":[{"CertificateArn":"","Id":"","SyncShadow":"","ThingArn":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Cores": [\n    {\n      "CertificateArn": "",\n      "Id": "",\n      "SyncShadow": "",\n      "ThingArn": ""\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  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions")
  .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/greengrass/definition/cores/:CoreDefinitionId/versions',
  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({Cores: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {Cores: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions');

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

req.type('json');
req.send({
  Cores: [
    {
      CertificateArn: '',
      Id: '',
      SyncShadow: '',
      ThingArn: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Cores: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Cores":[{"CertificateArn":"","Id":"","SyncShadow":"","ThingArn":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Cores": @[ @{ @"CertificateArn": @"", @"Id": @"", @"SyncShadow": @"", @"ThingArn": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions"]
                                                       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}}/greengrass/definition/cores/:CoreDefinitionId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions",
  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([
    'Cores' => [
        [
                'CertificateArn' => '',
                'Id' => '',
                'SyncShadow' => '',
                'ThingArn' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions', [
  'body' => '{
  "Cores": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Cores' => [
    [
        'CertificateArn' => '',
        'Id' => '',
        'SyncShadow' => '',
        'ThingArn' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Cores' => [
    [
        'CertificateArn' => '',
        'Id' => '',
        'SyncShadow' => '',
        'ThingArn' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions');
$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}}/greengrass/definition/cores/:CoreDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Cores": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Cores": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/cores/:CoreDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions"

payload = { "Cores": [
        {
            "CertificateArn": "",
            "Id": "",
            "SyncShadow": "",
            "ThingArn": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions"

payload <- "{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/cores/:CoreDefinitionId/versions")

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  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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/greengrass/definition/cores/:CoreDefinitionId/versions') do |req|
  req.body = "{\n  \"Cores\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/cores/:CoreDefinitionId/versions";

    let payload = json!({"Cores": (
            json!({
                "CertificateArn": "",
                "Id": "",
                "SyncShadow": "",
                "ThingArn": ""
            })
        )});

    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 '{
  "Cores": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Cores": [\n    {\n      "CertificateArn": "",\n      "Id": "",\n      "SyncShadow": "",\n      "ThingArn": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Cores": [
    [
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions")! 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}}/greengrass/groups/:GroupId/deployments");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/groups/:GroupId/deployments" {:content-type :json
                                                                                   :form-params {:DeploymentId ""
                                                                                                 :DeploymentType ""
                                                                                                 :GroupVersionId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/deployments"

	payload := strings.NewReader("{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\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/greengrass/groups/:GroupId/deployments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "DeploymentId": "",
  "DeploymentType": "",
  "GroupVersionId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/groups/:GroupId/deployments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/groups/:GroupId/deployments")
  .header("content-type", "application/json")
  .body("{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DeploymentId: '',
  DeploymentType: '',
  GroupVersionId: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/deployments',
  headers: {'content-type': 'application/json'},
  data: {DeploymentId: '', DeploymentType: '', GroupVersionId: ''}
};

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/deployments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeploymentId":"","DeploymentType":"","GroupVersionId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/groups/:GroupId/deployments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeploymentId": "",\n  "DeploymentType": "",\n  "GroupVersionId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/deployments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({DeploymentId: '', DeploymentType: '', GroupVersionId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/deployments',
  headers: {'content-type': 'application/json'},
  body: {DeploymentId: '', DeploymentType: '', GroupVersionId: ''},
  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}}/greengrass/groups/:GroupId/deployments');

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

req.type('json');
req.send({
  DeploymentId: '',
  DeploymentType: '',
  GroupVersionId: ''
});

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}}/greengrass/groups/:GroupId/deployments',
  headers: {'content-type': 'application/json'},
  data: {DeploymentId: '', DeploymentType: '', GroupVersionId: ''}
};

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

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/deployments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeploymentId":"","DeploymentType":"","GroupVersionId":""}'
};

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 = @{ @"DeploymentId": @"",
                              @"DeploymentType": @"",
                              @"GroupVersionId": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/greengrass/groups/:GroupId/deployments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}" in

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

 "{{baseUrl}}/greengrass/groups/:GroupId/deployments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DeploymentId' => '',
    'DeploymentType' => '',
    'GroupVersionId' => ''
  ]),
  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}}/greengrass/groups/:GroupId/deployments', [
  'body' => '{
  "DeploymentId": "",
  "DeploymentType": "",
  "GroupVersionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/deployments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeploymentId' => '',
  'DeploymentType' => '',
  'GroupVersionId' => ''
]));

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

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

append(json_encode([
  'DeploymentId' => '',
  'DeploymentType' => '',
  'GroupVersionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/deployments');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/deployments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeploymentId": "",
  "DeploymentType": "",
  "GroupVersionId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/deployments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeploymentId": "",
  "DeploymentType": "",
  "GroupVersionId": ""
}'

import http.client

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

payload = "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/greengrass/groups/:GroupId/deployments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/deployments"

payload = {
    "DeploymentId": "",
    "DeploymentType": "",
    "GroupVersionId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/deployments"

payload <- "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\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}}/greengrass/groups/:GroupId/deployments")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\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/greengrass/groups/:GroupId/deployments') do |req|
  req.body = "{\n  \"DeploymentId\": \"\",\n  \"DeploymentType\": \"\",\n  \"GroupVersionId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "DeploymentId": "",
        "DeploymentType": "",
        "GroupVersionId": ""
    });

    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 '{
  "DeploymentId": "",
  "DeploymentType": "",
  "GroupVersionId": ""
}' |  \
  http POST {{baseUrl}}/greengrass/groups/:GroupId/deployments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeploymentId": "",\n  "DeploymentType": "",\n  "GroupVersionId": ""\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/deployments

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/devices");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/devices" {:content-type :json
                                                                          :form-params {:InitialVersion {:Devices ""}
                                                                                        :Name ""
                                                                                        :tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/devices"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "InitialVersion": {
    "Devices": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/devices")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/devices")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    Devices: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/devices',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Devices: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Devices":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "Devices": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({InitialVersion: {Devices: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/devices',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {Devices: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/devices');

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

req.type('json');
req.send({
  InitialVersion: {
    Devices: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/devices',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Devices: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Devices":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"Devices": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/greengrass/definition/devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'InitialVersion' => [
        'Devices' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/devices', [
  'body' => '{
  "InitialVersion": {
    "Devices": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/devices');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'Devices' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'Devices' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/devices');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Devices": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Devices": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/devices", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/devices"

payload = {
    "InitialVersion": { "Devices": "" },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/devices"

payload <- "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/devices")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/devices') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"Devices\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({"Devices": ""}),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "Devices": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/devices \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "Devices": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/devices

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": ["Devices": ""],
  "Name": "",
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions");

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  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions" {:content-type :json
                                                                                                       :form-params {:Devices [{:CertificateArn ""
                                                                                                                                :Id ""
                                                                                                                                :SyncShadow ""
                                                                                                                                :ThingArn ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/devices/:DeviceDefinitionId/versions"),
    Content = new StringContent("{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/devices/:DeviceDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions"

	payload := strings.NewReader("{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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/greengrass/definition/devices/:DeviceDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "Devices": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Devices: [
    {
      CertificateArn: '',
      Id: '',
      SyncShadow: '',
      ThingArn: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Devices: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]}
};

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

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Devices":[{"CertificateArn":"","Id":"","SyncShadow":"","ThingArn":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Devices": [\n    {\n      "CertificateArn": "",\n      "Id": "",\n      "SyncShadow": "",\n      "ThingArn": ""\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  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions")
  .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/greengrass/definition/devices/:DeviceDefinitionId/versions',
  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({Devices: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {Devices: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions');

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

req.type('json');
req.send({
  Devices: [
    {
      CertificateArn: '',
      Id: '',
      SyncShadow: '',
      ThingArn: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Devices: [{CertificateArn: '', Id: '', SyncShadow: '', ThingArn: ''}]}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Devices":[{"CertificateArn":"","Id":"","SyncShadow":"","ThingArn":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Devices": @[ @{ @"CertificateArn": @"", @"Id": @"", @"SyncShadow": @"", @"ThingArn": @"" } ] };

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

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

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

 "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions",
  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([
    'Devices' => [
        [
                'CertificateArn' => '',
                'Id' => '',
                'SyncShadow' => '',
                'ThingArn' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions', [
  'body' => '{
  "Devices": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Devices' => [
    [
        'CertificateArn' => '',
        'Id' => '',
        'SyncShadow' => '',
        'ThingArn' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Devices' => [
    [
        'CertificateArn' => '',
        'Id' => '',
        'SyncShadow' => '',
        'ThingArn' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions');
$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}}/greengrass/definition/devices/:DeviceDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Devices": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Devices": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/devices/:DeviceDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions"

payload = { "Devices": [
        {
            "CertificateArn": "",
            "Id": "",
            "SyncShadow": "",
            "ThingArn": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions"

payload <- "{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/devices/:DeviceDefinitionId/versions")

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  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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/greengrass/definition/devices/:DeviceDefinitionId/versions') do |req|
  req.body = "{\n  \"Devices\": [\n    {\n      \"CertificateArn\": \"\",\n      \"Id\": \"\",\n      \"SyncShadow\": \"\",\n      \"ThingArn\": \"\"\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}}/greengrass/definition/devices/:DeviceDefinitionId/versions";

    let payload = json!({"Devices": (
            json!({
                "CertificateArn": "",
                "Id": "",
                "SyncShadow": "",
                "ThingArn": ""
            })
        )});

    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 '{
  "Devices": [
    {
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Devices": [\n    {\n      "CertificateArn": "",\n      "Id": "",\n      "SyncShadow": "",\n      "ThingArn": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Devices": [
    [
      "CertificateArn": "",
      "Id": "",
      "SyncShadow": "",
      "ThingArn": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions")! 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}}/greengrass/definition/functions");

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  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/functions" {:content-type :json
                                                                            :form-params {:InitialVersion {:DefaultConfig ""
                                                                                                           :Functions ""}
                                                                                          :Name ""
                                                                                          :tags {}}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/functions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/functions"),
    Content = new StringContent("{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/functions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/functions"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/functions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "InitialVersion": {
    "DefaultConfig": "",
    "Functions": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/functions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/functions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/functions")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    DefaultConfig: '',
    Functions: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/functions',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {DefaultConfig: '', Functions: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/functions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"DefaultConfig":"","Functions":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/functions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "DefaultConfig": "",\n    "Functions": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions")
  .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/greengrass/definition/functions',
  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({InitialVersion: {DefaultConfig: '', Functions: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/functions',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {DefaultConfig: '', Functions: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/functions');

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

req.type('json');
req.send({
  InitialVersion: {
    DefaultConfig: '',
    Functions: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/functions',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {DefaultConfig: '', Functions: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/functions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"DefaultConfig":"","Functions":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"DefaultConfig": @"", @"Functions": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/functions"]
                                                       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}}/greengrass/definition/functions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/functions",
  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([
    'InitialVersion' => [
        'DefaultConfig' => '',
        'Functions' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/functions', [
  'body' => '{
  "InitialVersion": {
    "DefaultConfig": "",
    "Functions": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/functions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'DefaultConfig' => '',
    'Functions' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'DefaultConfig' => '',
    'Functions' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/functions');
$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}}/greengrass/definition/functions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "DefaultConfig": "",
    "Functions": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/functions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "DefaultConfig": "",
    "Functions": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/functions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/functions"

payload = {
    "InitialVersion": {
        "DefaultConfig": "",
        "Functions": ""
    },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/functions"

payload <- "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/functions")

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  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/functions') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"DefaultConfig\": \"\",\n    \"Functions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({
            "DefaultConfig": "",
            "Functions": ""
        }),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "DefaultConfig": "",
    "Functions": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/functions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "DefaultConfig": "",\n    "Functions": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/functions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": [
    "DefaultConfig": "",
    "Functions": ""
  ],
  "Name": "",
  "tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/functions")! 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}}/greengrass/definition/functions/:FunctionDefinitionId/versions");

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  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions" {:content-type :json
                                                                                                           :form-params {:DefaultConfig {:Execution {:IsolationMode ""
                                                                                                                                                     :RunAs {:Gid ""
                                                                                                                                                             :Uid ""}}}
                                                                                                                         :Functions [{:FunctionArn ""
                                                                                                                                      :FunctionConfiguration ""
                                                                                                                                      :Id ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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}}/greengrass/definition/functions/:FunctionDefinitionId/versions"),
    Content = new StringContent("{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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}}/greengrass/definition/functions/:FunctionDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions"

	payload := strings.NewReader("{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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/greengrass/definition/functions/:FunctionDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 251

{
  "DefaultConfig": {
    "Execution": {
      "IsolationMode": "",
      "RunAs": {
        "Gid": "",
        "Uid": ""
      }
    }
  },
  "Functions": [
    {
      "FunctionArn": "",
      "FunctionConfiguration": "",
      "Id": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  DefaultConfig: {
    Execution: {
      IsolationMode: '',
      RunAs: {
        Gid: '',
        Uid: ''
      }
    }
  },
  Functions: [
    {
      FunctionArn: '',
      FunctionConfiguration: '',
      Id: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultConfig: {Execution: {IsolationMode: '', RunAs: {Gid: '', Uid: ''}}},
    Functions: [{FunctionArn: '', FunctionConfiguration: '', Id: ''}]
  }
};

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

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultConfig":{"Execution":{"IsolationMode":"","RunAs":{"Gid":"","Uid":""}}},"Functions":[{"FunctionArn":"","FunctionConfiguration":"","Id":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DefaultConfig": {\n    "Execution": {\n      "IsolationMode": "",\n      "RunAs": {\n        "Gid": "",\n        "Uid": ""\n      }\n    }\n  },\n  "Functions": [\n    {\n      "FunctionArn": "",\n      "FunctionConfiguration": "",\n      "Id": ""\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  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions")
  .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/greengrass/definition/functions/:FunctionDefinitionId/versions',
  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({
  DefaultConfig: {Execution: {IsolationMode: '', RunAs: {Gid: '', Uid: ''}}},
  Functions: [{FunctionArn: '', FunctionConfiguration: '', Id: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {
    DefaultConfig: {Execution: {IsolationMode: '', RunAs: {Gid: '', Uid: ''}}},
    Functions: [{FunctionArn: '', FunctionConfiguration: '', Id: ''}]
  },
  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}}/greengrass/definition/functions/:FunctionDefinitionId/versions');

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

req.type('json');
req.send({
  DefaultConfig: {
    Execution: {
      IsolationMode: '',
      RunAs: {
        Gid: '',
        Uid: ''
      }
    }
  },
  Functions: [
    {
      FunctionArn: '',
      FunctionConfiguration: '',
      Id: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {
    DefaultConfig: {Execution: {IsolationMode: '', RunAs: {Gid: '', Uid: ''}}},
    Functions: [{FunctionArn: '', FunctionConfiguration: '', Id: ''}]
  }
};

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

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

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DefaultConfig":{"Execution":{"IsolationMode":"","RunAs":{"Gid":"","Uid":""}}},"Functions":[{"FunctionArn":"","FunctionConfiguration":"","Id":""}]}'
};

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 = @{ @"DefaultConfig": @{ @"Execution": @{ @"IsolationMode": @"", @"RunAs": @{ @"Gid": @"", @"Uid": @"" } } },
                              @"Functions": @[ @{ @"FunctionArn": @"", @"FunctionConfiguration": @"", @"Id": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions"]
                                                       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}}/greengrass/definition/functions/:FunctionDefinitionId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions",
  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([
    'DefaultConfig' => [
        'Execution' => [
                'IsolationMode' => '',
                'RunAs' => [
                                'Gid' => '',
                                'Uid' => ''
                ]
        ]
    ],
    'Functions' => [
        [
                'FunctionArn' => '',
                'FunctionConfiguration' => '',
                'Id' => ''
        ]
    ]
  ]),
  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}}/greengrass/definition/functions/:FunctionDefinitionId/versions', [
  'body' => '{
  "DefaultConfig": {
    "Execution": {
      "IsolationMode": "",
      "RunAs": {
        "Gid": "",
        "Uid": ""
      }
    }
  },
  "Functions": [
    {
      "FunctionArn": "",
      "FunctionConfiguration": "",
      "Id": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DefaultConfig' => [
    'Execution' => [
        'IsolationMode' => '',
        'RunAs' => [
                'Gid' => '',
                'Uid' => ''
        ]
    ]
  ],
  'Functions' => [
    [
        'FunctionArn' => '',
        'FunctionConfiguration' => '',
        'Id' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'DefaultConfig' => [
    'Execution' => [
        'IsolationMode' => '',
        'RunAs' => [
                'Gid' => '',
                'Uid' => ''
        ]
    ]
  ],
  'Functions' => [
    [
        'FunctionArn' => '',
        'FunctionConfiguration' => '',
        'Id' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions');
$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}}/greengrass/definition/functions/:FunctionDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultConfig": {
    "Execution": {
      "IsolationMode": "",
      "RunAs": {
        "Gid": "",
        "Uid": ""
      }
    }
  },
  "Functions": [
    {
      "FunctionArn": "",
      "FunctionConfiguration": "",
      "Id": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DefaultConfig": {
    "Execution": {
      "IsolationMode": "",
      "RunAs": {
        "Gid": "",
        "Uid": ""
      }
    }
  },
  "Functions": [
    {
      "FunctionArn": "",
      "FunctionConfiguration": "",
      "Id": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/functions/:FunctionDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions"

payload = {
    "DefaultConfig": { "Execution": {
            "IsolationMode": "",
            "RunAs": {
                "Gid": "",
                "Uid": ""
            }
        } },
    "Functions": [
        {
            "FunctionArn": "",
            "FunctionConfiguration": "",
            "Id": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions"

payload <- "{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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}}/greengrass/definition/functions/:FunctionDefinitionId/versions")

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  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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/greengrass/definition/functions/:FunctionDefinitionId/versions') do |req|
  req.body = "{\n  \"DefaultConfig\": {\n    \"Execution\": {\n      \"IsolationMode\": \"\",\n      \"RunAs\": {\n        \"Gid\": \"\",\n        \"Uid\": \"\"\n      }\n    }\n  },\n  \"Functions\": [\n    {\n      \"FunctionArn\": \"\",\n      \"FunctionConfiguration\": \"\",\n      \"Id\": \"\"\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}}/greengrass/definition/functions/:FunctionDefinitionId/versions";

    let payload = json!({
        "DefaultConfig": json!({"Execution": json!({
                "IsolationMode": "",
                "RunAs": json!({
                    "Gid": "",
                    "Uid": ""
                })
            })}),
        "Functions": (
            json!({
                "FunctionArn": "",
                "FunctionConfiguration": "",
                "Id": ""
            })
        )
    });

    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 '{
  "DefaultConfig": {
    "Execution": {
      "IsolationMode": "",
      "RunAs": {
        "Gid": "",
        "Uid": ""
      }
    }
  },
  "Functions": [
    {
      "FunctionArn": "",
      "FunctionConfiguration": "",
      "Id": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DefaultConfig": {\n    "Execution": {\n      "IsolationMode": "",\n      "RunAs": {\n        "Gid": "",\n        "Uid": ""\n      }\n    }\n  },\n  "Functions": [\n    {\n      "FunctionArn": "",\n      "FunctionConfiguration": "",\n      "Id": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DefaultConfig": ["Execution": [
      "IsolationMode": "",
      "RunAs": [
        "Gid": "",
        "Uid": ""
      ]
    ]],
  "Functions": [
    [
      "FunctionArn": "",
      "FunctionConfiguration": "",
      "Id": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions")! 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}}/greengrass/groups");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/groups" {:content-type :json
                                                              :form-params {:InitialVersion {:ConnectorDefinitionVersionArn ""
                                                                                             :CoreDefinitionVersionArn ""
                                                                                             :DeviceDefinitionVersionArn ""
                                                                                             :FunctionDefinitionVersionArn ""
                                                                                             :LoggerDefinitionVersionArn ""
                                                                                             :ResourceDefinitionVersionArn ""
                                                                                             :SubscriptionDefinitionVersionArn ""}
                                                                            :Name ""
                                                                            :tags {}}})

require "http/client"

url = "{{baseUrl}}/greengrass/groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/groups"),
    Content = new StringContent("{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/groups"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "InitialVersion": {
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/groups")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    ConnectorDefinitionVersionArn: '',
    CoreDefinitionVersionArn: '',
    DeviceDefinitionVersionArn: '',
    FunctionDefinitionVersionArn: '',
    LoggerDefinitionVersionArn: '',
    ResourceDefinitionVersionArn: '',
    SubscriptionDefinitionVersionArn: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups',
  headers: {'content-type': 'application/json'},
  data: {
    InitialVersion: {
      ConnectorDefinitionVersionArn: '',
      CoreDefinitionVersionArn: '',
      DeviceDefinitionVersionArn: '',
      FunctionDefinitionVersionArn: '',
      LoggerDefinitionVersionArn: '',
      ResourceDefinitionVersionArn: '',
      SubscriptionDefinitionVersionArn: ''
    },
    Name: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/greengrass/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"ConnectorDefinitionVersionArn":"","CoreDefinitionVersionArn":"","DeviceDefinitionVersionArn":"","FunctionDefinitionVersionArn":"","LoggerDefinitionVersionArn":"","ResourceDefinitionVersionArn":"","SubscriptionDefinitionVersionArn":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "ConnectorDefinitionVersionArn": "",\n    "CoreDefinitionVersionArn": "",\n    "DeviceDefinitionVersionArn": "",\n    "FunctionDefinitionVersionArn": "",\n    "LoggerDefinitionVersionArn": "",\n    "ResourceDefinitionVersionArn": "",\n    "SubscriptionDefinitionVersionArn": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  InitialVersion: {
    ConnectorDefinitionVersionArn: '',
    CoreDefinitionVersionArn: '',
    DeviceDefinitionVersionArn: '',
    FunctionDefinitionVersionArn: '',
    LoggerDefinitionVersionArn: '',
    ResourceDefinitionVersionArn: '',
    SubscriptionDefinitionVersionArn: ''
  },
  Name: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups',
  headers: {'content-type': 'application/json'},
  body: {
    InitialVersion: {
      ConnectorDefinitionVersionArn: '',
      CoreDefinitionVersionArn: '',
      DeviceDefinitionVersionArn: '',
      FunctionDefinitionVersionArn: '',
      LoggerDefinitionVersionArn: '',
      ResourceDefinitionVersionArn: '',
      SubscriptionDefinitionVersionArn: ''
    },
    Name: '',
    tags: {}
  },
  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}}/greengrass/groups');

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

req.type('json');
req.send({
  InitialVersion: {
    ConnectorDefinitionVersionArn: '',
    CoreDefinitionVersionArn: '',
    DeviceDefinitionVersionArn: '',
    FunctionDefinitionVersionArn: '',
    LoggerDefinitionVersionArn: '',
    ResourceDefinitionVersionArn: '',
    SubscriptionDefinitionVersionArn: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/groups',
  headers: {'content-type': 'application/json'},
  data: {
    InitialVersion: {
      ConnectorDefinitionVersionArn: '',
      CoreDefinitionVersionArn: '',
      DeviceDefinitionVersionArn: '',
      FunctionDefinitionVersionArn: '',
      LoggerDefinitionVersionArn: '',
      ResourceDefinitionVersionArn: '',
      SubscriptionDefinitionVersionArn: ''
    },
    Name: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/greengrass/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"ConnectorDefinitionVersionArn":"","CoreDefinitionVersionArn":"","DeviceDefinitionVersionArn":"","FunctionDefinitionVersionArn":"","LoggerDefinitionVersionArn":"","ResourceDefinitionVersionArn":"","SubscriptionDefinitionVersionArn":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"ConnectorDefinitionVersionArn": @"", @"CoreDefinitionVersionArn": @"", @"DeviceDefinitionVersionArn": @"", @"FunctionDefinitionVersionArn": @"", @"LoggerDefinitionVersionArn": @"", @"ResourceDefinitionVersionArn": @"", @"SubscriptionDefinitionVersionArn": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/greengrass/groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'InitialVersion' => [
        'ConnectorDefinitionVersionArn' => '',
        'CoreDefinitionVersionArn' => '',
        'DeviceDefinitionVersionArn' => '',
        'FunctionDefinitionVersionArn' => '',
        'LoggerDefinitionVersionArn' => '',
        'ResourceDefinitionVersionArn' => '',
        'SubscriptionDefinitionVersionArn' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/groups', [
  'body' => '{
  "InitialVersion": {
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'ConnectorDefinitionVersionArn' => '',
    'CoreDefinitionVersionArn' => '',
    'DeviceDefinitionVersionArn' => '',
    'FunctionDefinitionVersionArn' => '',
    'LoggerDefinitionVersionArn' => '',
    'ResourceDefinitionVersionArn' => '',
    'SubscriptionDefinitionVersionArn' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'ConnectorDefinitionVersionArn' => '',
    'CoreDefinitionVersionArn' => '',
    'DeviceDefinitionVersionArn' => '',
    'FunctionDefinitionVersionArn' => '',
    'LoggerDefinitionVersionArn' => '',
    'ResourceDefinitionVersionArn' => '',
    'SubscriptionDefinitionVersionArn' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/groups');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/greengrass/groups"

payload = {
    "InitialVersion": {
        "ConnectorDefinitionVersionArn": "",
        "CoreDefinitionVersionArn": "",
        "DeviceDefinitionVersionArn": "",
        "FunctionDefinitionVersionArn": "",
        "LoggerDefinitionVersionArn": "",
        "ResourceDefinitionVersionArn": "",
        "SubscriptionDefinitionVersionArn": ""
    },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/groups")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/groups') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"ConnectorDefinitionVersionArn\": \"\",\n    \"CoreDefinitionVersionArn\": \"\",\n    \"DeviceDefinitionVersionArn\": \"\",\n    \"FunctionDefinitionVersionArn\": \"\",\n    \"LoggerDefinitionVersionArn\": \"\",\n    \"ResourceDefinitionVersionArn\": \"\",\n    \"SubscriptionDefinitionVersionArn\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({
            "ConnectorDefinitionVersionArn": "",
            "CoreDefinitionVersionArn": "",
            "DeviceDefinitionVersionArn": "",
            "FunctionDefinitionVersionArn": "",
            "LoggerDefinitionVersionArn": "",
            "ResourceDefinitionVersionArn": "",
            "SubscriptionDefinitionVersionArn": ""
        }),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "ConnectorDefinitionVersionArn": "",\n    "CoreDefinitionVersionArn": "",\n    "DeviceDefinitionVersionArn": "",\n    "FunctionDefinitionVersionArn": "",\n    "LoggerDefinitionVersionArn": "",\n    "ResourceDefinitionVersionArn": "",\n    "SubscriptionDefinitionVersionArn": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": [
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
  ],
  "Name": "",
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities"

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

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

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities"

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

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

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

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

}

POST /baseUrl/greengrass/groups/:GroupId/certificateauthorities HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities'
};

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/certificateauthorities',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities');

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}}/greengrass/groups/:GroupId/certificateauthorities'
};

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

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities" in

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

 "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/greengrass/groups/:GroupId/certificateauthorities")

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

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

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/greengrass/groups/:GroupId/certificateauthorities') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/groups/:GroupId/versions");

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  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/groups/:GroupId/versions" {:content-type :json
                                                                                :form-params {:ConnectorDefinitionVersionArn ""
                                                                                              :CoreDefinitionVersionArn ""
                                                                                              :DeviceDefinitionVersionArn ""
                                                                                              :FunctionDefinitionVersionArn ""
                                                                                              :LoggerDefinitionVersionArn ""
                                                                                              :ResourceDefinitionVersionArn ""
                                                                                              :SubscriptionDefinitionVersionArn ""}})

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\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}}/greengrass/groups/:GroupId/versions"),
    Content = new StringContent("{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\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}}/greengrass/groups/:GroupId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/versions"

	payload := strings.NewReader("{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\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/greengrass/groups/:GroupId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 265

{
  "ConnectorDefinitionVersionArn": "",
  "CoreDefinitionVersionArn": "",
  "DeviceDefinitionVersionArn": "",
  "FunctionDefinitionVersionArn": "",
  "LoggerDefinitionVersionArn": "",
  "ResourceDefinitionVersionArn": "",
  "SubscriptionDefinitionVersionArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/groups/:GroupId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\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  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/groups/:GroupId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ConnectorDefinitionVersionArn: '',
  CoreDefinitionVersionArn: '',
  DeviceDefinitionVersionArn: '',
  FunctionDefinitionVersionArn: '',
  LoggerDefinitionVersionArn: '',
  ResourceDefinitionVersionArn: '',
  SubscriptionDefinitionVersionArn: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/versions',
  headers: {'content-type': 'application/json'},
  data: {
    ConnectorDefinitionVersionArn: '',
    CoreDefinitionVersionArn: '',
    DeviceDefinitionVersionArn: '',
    FunctionDefinitionVersionArn: '',
    LoggerDefinitionVersionArn: '',
    ResourceDefinitionVersionArn: '',
    SubscriptionDefinitionVersionArn: ''
  }
};

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ConnectorDefinitionVersionArn":"","CoreDefinitionVersionArn":"","DeviceDefinitionVersionArn":"","FunctionDefinitionVersionArn":"","LoggerDefinitionVersionArn":"","ResourceDefinitionVersionArn":"","SubscriptionDefinitionVersionArn":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/groups/:GroupId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ConnectorDefinitionVersionArn": "",\n  "CoreDefinitionVersionArn": "",\n  "DeviceDefinitionVersionArn": "",\n  "FunctionDefinitionVersionArn": "",\n  "LoggerDefinitionVersionArn": "",\n  "ResourceDefinitionVersionArn": "",\n  "SubscriptionDefinitionVersionArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/versions")
  .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/greengrass/groups/:GroupId/versions',
  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({
  ConnectorDefinitionVersionArn: '',
  CoreDefinitionVersionArn: '',
  DeviceDefinitionVersionArn: '',
  FunctionDefinitionVersionArn: '',
  LoggerDefinitionVersionArn: '',
  ResourceDefinitionVersionArn: '',
  SubscriptionDefinitionVersionArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/versions',
  headers: {'content-type': 'application/json'},
  body: {
    ConnectorDefinitionVersionArn: '',
    CoreDefinitionVersionArn: '',
    DeviceDefinitionVersionArn: '',
    FunctionDefinitionVersionArn: '',
    LoggerDefinitionVersionArn: '',
    ResourceDefinitionVersionArn: '',
    SubscriptionDefinitionVersionArn: ''
  },
  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}}/greengrass/groups/:GroupId/versions');

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

req.type('json');
req.send({
  ConnectorDefinitionVersionArn: '',
  CoreDefinitionVersionArn: '',
  DeviceDefinitionVersionArn: '',
  FunctionDefinitionVersionArn: '',
  LoggerDefinitionVersionArn: '',
  ResourceDefinitionVersionArn: '',
  SubscriptionDefinitionVersionArn: ''
});

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}}/greengrass/groups/:GroupId/versions',
  headers: {'content-type': 'application/json'},
  data: {
    ConnectorDefinitionVersionArn: '',
    CoreDefinitionVersionArn: '',
    DeviceDefinitionVersionArn: '',
    FunctionDefinitionVersionArn: '',
    LoggerDefinitionVersionArn: '',
    ResourceDefinitionVersionArn: '',
    SubscriptionDefinitionVersionArn: ''
  }
};

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

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ConnectorDefinitionVersionArn":"","CoreDefinitionVersionArn":"","DeviceDefinitionVersionArn":"","FunctionDefinitionVersionArn":"","LoggerDefinitionVersionArn":"","ResourceDefinitionVersionArn":"","SubscriptionDefinitionVersionArn":""}'
};

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 = @{ @"ConnectorDefinitionVersionArn": @"",
                              @"CoreDefinitionVersionArn": @"",
                              @"DeviceDefinitionVersionArn": @"",
                              @"FunctionDefinitionVersionArn": @"",
                              @"LoggerDefinitionVersionArn": @"",
                              @"ResourceDefinitionVersionArn": @"",
                              @"SubscriptionDefinitionVersionArn": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/groups/:GroupId/versions"]
                                                       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}}/greengrass/groups/:GroupId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}" in

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

 "{{baseUrl}}/greengrass/groups/:GroupId/versions",
  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([
    'ConnectorDefinitionVersionArn' => '',
    'CoreDefinitionVersionArn' => '',
    'DeviceDefinitionVersionArn' => '',
    'FunctionDefinitionVersionArn' => '',
    'LoggerDefinitionVersionArn' => '',
    'ResourceDefinitionVersionArn' => '',
    'SubscriptionDefinitionVersionArn' => ''
  ]),
  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}}/greengrass/groups/:GroupId/versions', [
  'body' => '{
  "ConnectorDefinitionVersionArn": "",
  "CoreDefinitionVersionArn": "",
  "DeviceDefinitionVersionArn": "",
  "FunctionDefinitionVersionArn": "",
  "LoggerDefinitionVersionArn": "",
  "ResourceDefinitionVersionArn": "",
  "SubscriptionDefinitionVersionArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ConnectorDefinitionVersionArn' => '',
  'CoreDefinitionVersionArn' => '',
  'DeviceDefinitionVersionArn' => '',
  'FunctionDefinitionVersionArn' => '',
  'LoggerDefinitionVersionArn' => '',
  'ResourceDefinitionVersionArn' => '',
  'SubscriptionDefinitionVersionArn' => ''
]));

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

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

append(json_encode([
  'ConnectorDefinitionVersionArn' => '',
  'CoreDefinitionVersionArn' => '',
  'DeviceDefinitionVersionArn' => '',
  'FunctionDefinitionVersionArn' => '',
  'LoggerDefinitionVersionArn' => '',
  'ResourceDefinitionVersionArn' => '',
  'SubscriptionDefinitionVersionArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/versions');
$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}}/greengrass/groups/:GroupId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ConnectorDefinitionVersionArn": "",
  "CoreDefinitionVersionArn": "",
  "DeviceDefinitionVersionArn": "",
  "FunctionDefinitionVersionArn": "",
  "LoggerDefinitionVersionArn": "",
  "ResourceDefinitionVersionArn": "",
  "SubscriptionDefinitionVersionArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ConnectorDefinitionVersionArn": "",
  "CoreDefinitionVersionArn": "",
  "DeviceDefinitionVersionArn": "",
  "FunctionDefinitionVersionArn": "",
  "LoggerDefinitionVersionArn": "",
  "ResourceDefinitionVersionArn": "",
  "SubscriptionDefinitionVersionArn": ""
}'

import http.client

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

payload = "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}"

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

conn.request("POST", "/baseUrl/greengrass/groups/:GroupId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/versions"

payload = {
    "ConnectorDefinitionVersionArn": "",
    "CoreDefinitionVersionArn": "",
    "DeviceDefinitionVersionArn": "",
    "FunctionDefinitionVersionArn": "",
    "LoggerDefinitionVersionArn": "",
    "ResourceDefinitionVersionArn": "",
    "SubscriptionDefinitionVersionArn": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/versions"

payload <- "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\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}}/greengrass/groups/:GroupId/versions")

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  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\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/greengrass/groups/:GroupId/versions') do |req|
  req.body = "{\n  \"ConnectorDefinitionVersionArn\": \"\",\n  \"CoreDefinitionVersionArn\": \"\",\n  \"DeviceDefinitionVersionArn\": \"\",\n  \"FunctionDefinitionVersionArn\": \"\",\n  \"LoggerDefinitionVersionArn\": \"\",\n  \"ResourceDefinitionVersionArn\": \"\",\n  \"SubscriptionDefinitionVersionArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ConnectorDefinitionVersionArn": "",
        "CoreDefinitionVersionArn": "",
        "DeviceDefinitionVersionArn": "",
        "FunctionDefinitionVersionArn": "",
        "LoggerDefinitionVersionArn": "",
        "ResourceDefinitionVersionArn": "",
        "SubscriptionDefinitionVersionArn": ""
    });

    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 '{
  "ConnectorDefinitionVersionArn": "",
  "CoreDefinitionVersionArn": "",
  "DeviceDefinitionVersionArn": "",
  "FunctionDefinitionVersionArn": "",
  "LoggerDefinitionVersionArn": "",
  "ResourceDefinitionVersionArn": "",
  "SubscriptionDefinitionVersionArn": ""
}' |  \
  http POST {{baseUrl}}/greengrass/groups/:GroupId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ConnectorDefinitionVersionArn": "",\n  "CoreDefinitionVersionArn": "",\n  "DeviceDefinitionVersionArn": "",\n  "FunctionDefinitionVersionArn": "",\n  "LoggerDefinitionVersionArn": "",\n  "ResourceDefinitionVersionArn": "",\n  "SubscriptionDefinitionVersionArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ConnectorDefinitionVersionArn": "",
  "CoreDefinitionVersionArn": "",
  "DeviceDefinitionVersionArn": "",
  "FunctionDefinitionVersionArn": "",
  "LoggerDefinitionVersionArn": "",
  "ResourceDefinitionVersionArn": "",
  "SubscriptionDefinitionVersionArn": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/versions")! 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}}/greengrass/definition/loggers");

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  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/loggers" {:content-type :json
                                                                          :form-params {:InitialVersion {:Loggers ""}
                                                                                        :Name ""
                                                                                        :tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/loggers"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/loggers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "InitialVersion": {
    "Loggers": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/loggers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/loggers")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    Loggers: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/loggers',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Loggers: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/loggers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Loggers":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/loggers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "Loggers": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/loggers")
  .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/greengrass/definition/loggers',
  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({InitialVersion: {Loggers: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/loggers',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {Loggers: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/loggers');

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

req.type('json');
req.send({
  InitialVersion: {
    Loggers: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/loggers',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Loggers: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/loggers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Loggers":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"Loggers": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/loggers"]
                                                       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}}/greengrass/definition/loggers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/loggers",
  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([
    'InitialVersion' => [
        'Loggers' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/loggers', [
  'body' => '{
  "InitialVersion": {
    "Loggers": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/loggers');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'Loggers' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'Loggers' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/loggers');
$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}}/greengrass/definition/loggers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Loggers": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/loggers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Loggers": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/loggers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/loggers"

payload = {
    "InitialVersion": { "Loggers": "" },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/loggers"

payload <- "{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/loggers")

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  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/loggers') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"Loggers\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({"Loggers": ""}),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "Loggers": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/loggers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "Loggers": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/loggers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": ["Loggers": ""],
  "Name": "",
  "tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/loggers")! 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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions");

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  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions" {:content-type :json
                                                                                                       :form-params {:Loggers [{:Component ""
                                                                                                                                :Id ""
                                                                                                                                :Level ""
                                                                                                                                :Space ""
                                                                                                                                :Type ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"),
    Content = new StringContent("{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"

	payload := strings.NewReader("{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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/greengrass/definition/loggers/:LoggerDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 128

{
  "Loggers": [
    {
      "Component": "",
      "Id": "",
      "Level": "",
      "Space": "",
      "Type": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Loggers: [
    {
      Component: '',
      Id: '',
      Level: '',
      Space: '',
      Type: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Loggers: [{Component: '', Id: '', Level: '', Space: '', Type: ''}]}
};

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

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Loggers":[{"Component":"","Id":"","Level":"","Space":"","Type":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Loggers": [\n    {\n      "Component": "",\n      "Id": "",\n      "Level": "",\n      "Space": "",\n      "Type": ""\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  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions")
  .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/greengrass/definition/loggers/:LoggerDefinitionId/versions',
  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({Loggers: [{Component: '', Id: '', Level: '', Space: '', Type: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {Loggers: [{Component: '', Id: '', Level: '', Space: '', Type: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions');

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

req.type('json');
req.send({
  Loggers: [
    {
      Component: '',
      Id: '',
      Level: '',
      Space: '',
      Type: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Loggers: [{Component: '', Id: '', Level: '', Space: '', Type: ''}]}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Loggers":[{"Component":"","Id":"","Level":"","Space":"","Type":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Loggers": @[ @{ @"Component": @"", @"Id": @"", @"Level": @"", @"Space": @"", @"Type": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"]
                                                       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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions",
  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([
    'Loggers' => [
        [
                'Component' => '',
                'Id' => '',
                'Level' => '',
                'Space' => '',
                'Type' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions', [
  'body' => '{
  "Loggers": [
    {
      "Component": "",
      "Id": "",
      "Level": "",
      "Space": "",
      "Type": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Loggers' => [
    [
        'Component' => '',
        'Id' => '',
        'Level' => '',
        'Space' => '',
        'Type' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Loggers' => [
    [
        'Component' => '',
        'Id' => '',
        'Level' => '',
        'Space' => '',
        'Type' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions');
$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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Loggers": [
    {
      "Component": "",
      "Id": "",
      "Level": "",
      "Space": "",
      "Type": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Loggers": [
    {
      "Component": "",
      "Id": "",
      "Level": "",
      "Space": "",
      "Type": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"

payload = { "Loggers": [
        {
            "Component": "",
            "Id": "",
            "Level": "",
            "Space": "",
            "Type": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions"

payload <- "{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions")

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  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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/greengrass/definition/loggers/:LoggerDefinitionId/versions') do |req|
  req.body = "{\n  \"Loggers\": [\n    {\n      \"Component\": \"\",\n      \"Id\": \"\",\n      \"Level\": \"\",\n      \"Space\": \"\",\n      \"Type\": \"\"\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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions";

    let payload = json!({"Loggers": (
            json!({
                "Component": "",
                "Id": "",
                "Level": "",
                "Space": "",
                "Type": ""
            })
        )});

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

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

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

    dbg!(results);
}

echo '{
  "Loggers": [
    {
      "Component": "",
      "Id": "",
      "Level": "",
      "Space": "",
      "Type": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Loggers": [\n    {\n      "Component": "",\n      "Id": "",\n      "Level": "",\n      "Space": "",\n      "Type": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Loggers": [
    [
      "Component": "",
      "Id": "",
      "Level": "",
      "Space": "",
      "Type": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions")! 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}}/greengrass/definition/resources");

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  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/resources" {:content-type :json
                                                                            :form-params {:InitialVersion {:Resources ""}
                                                                                          :Name ""
                                                                                          :tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/resources"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/resources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "InitialVersion": {
    "Resources": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/resources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/resources")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    Resources: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/resources',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Resources: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/resources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Resources":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/resources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "Resources": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/resources")
  .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/greengrass/definition/resources',
  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({InitialVersion: {Resources: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/resources',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {Resources: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/resources');

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

req.type('json');
req.send({
  InitialVersion: {
    Resources: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/resources',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Resources: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/resources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Resources":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"Resources": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/resources"]
                                                       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}}/greengrass/definition/resources" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/resources",
  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([
    'InitialVersion' => [
        'Resources' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/resources', [
  'body' => '{
  "InitialVersion": {
    "Resources": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/resources');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'Resources' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'Resources' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/resources');
$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}}/greengrass/definition/resources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Resources": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/resources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Resources": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/resources", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/resources"

payload = {
    "InitialVersion": { "Resources": "" },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/resources"

payload <- "{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/resources")

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  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/resources') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"Resources\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({"Resources": ""}),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "Resources": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/resources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "Resources": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/resources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": ["Resources": ""],
  "Name": "",
  "tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/resources")! 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}}/greengrass/definition/resources/:ResourceDefinitionId/versions");

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  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions" {:content-type :json
                                                                                                           :form-params {:Resources [{:Id ""
                                                                                                                                      :Name ""
                                                                                                                                      :ResourceDataContainer ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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}}/greengrass/definition/resources/:ResourceDefinitionId/versions"),
    Content = new StringContent("{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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}}/greengrass/definition/resources/:ResourceDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions"

	payload := strings.NewReader("{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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/greengrass/definition/resources/:ResourceDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "Resources": [
    {
      "Id": "",
      "Name": "",
      "ResourceDataContainer": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Resources: [
    {
      Id: '',
      Name: '',
      ResourceDataContainer: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Resources: [{Id: '', Name: '', ResourceDataContainer: ''}]}
};

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

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Resources":[{"Id":"","Name":"","ResourceDataContainer":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Resources": [\n    {\n      "Id": "",\n      "Name": "",\n      "ResourceDataContainer": ""\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  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions")
  .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/greengrass/definition/resources/:ResourceDefinitionId/versions',
  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({Resources: [{Id: '', Name: '', ResourceDataContainer: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {Resources: [{Id: '', Name: '', ResourceDataContainer: ''}]},
  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}}/greengrass/definition/resources/:ResourceDefinitionId/versions');

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

req.type('json');
req.send({
  Resources: [
    {
      Id: '',
      Name: '',
      ResourceDataContainer: ''
    }
  ]
});

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}}/greengrass/definition/resources/:ResourceDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Resources: [{Id: '', Name: '', ResourceDataContainer: ''}]}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Resources":[{"Id":"","Name":"","ResourceDataContainer":""}]}'
};

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 = @{ @"Resources": @[ @{ @"Id": @"", @"Name": @"", @"ResourceDataContainer": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions"]
                                                       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}}/greengrass/definition/resources/:ResourceDefinitionId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions",
  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([
    'Resources' => [
        [
                'Id' => '',
                'Name' => '',
                'ResourceDataContainer' => ''
        ]
    ]
  ]),
  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}}/greengrass/definition/resources/:ResourceDefinitionId/versions', [
  'body' => '{
  "Resources": [
    {
      "Id": "",
      "Name": "",
      "ResourceDataContainer": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Resources' => [
    [
        'Id' => '',
        'Name' => '',
        'ResourceDataContainer' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Resources' => [
    [
        'Id' => '',
        'Name' => '',
        'ResourceDataContainer' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions');
$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}}/greengrass/definition/resources/:ResourceDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Resources": [
    {
      "Id": "",
      "Name": "",
      "ResourceDataContainer": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Resources": [
    {
      "Id": "",
      "Name": "",
      "ResourceDataContainer": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/resources/:ResourceDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions"

payload = { "Resources": [
        {
            "Id": "",
            "Name": "",
            "ResourceDataContainer": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions"

payload <- "{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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}}/greengrass/definition/resources/:ResourceDefinitionId/versions")

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  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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/greengrass/definition/resources/:ResourceDefinitionId/versions') do |req|
  req.body = "{\n  \"Resources\": [\n    {\n      \"Id\": \"\",\n      \"Name\": \"\",\n      \"ResourceDataContainer\": \"\"\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}}/greengrass/definition/resources/:ResourceDefinitionId/versions";

    let payload = json!({"Resources": (
            json!({
                "Id": "",
                "Name": "",
                "ResourceDataContainer": ""
            })
        )});

    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 '{
  "Resources": [
    {
      "Id": "",
      "Name": "",
      "ResourceDataContainer": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Resources": [\n    {\n      "Id": "",\n      "Name": "",\n      "ResourceDataContainer": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Resources": [
    [
      "Id": "",
      "Name": "",
      "ResourceDataContainer": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions")! 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}}/greengrass/updates");

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  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/updates" {:content-type :json
                                                               :form-params {:S3UrlSignerRole ""
                                                                             :SoftwareToUpdate ""
                                                                             :UpdateAgentLogLevel ""
                                                                             :UpdateTargets []
                                                                             :UpdateTargetsArchitecture ""
                                                                             :UpdateTargetsOperatingSystem ""}})

require "http/client"

url = "{{baseUrl}}/greengrass/updates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\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}}/greengrass/updates"),
    Content = new StringContent("{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\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}}/greengrass/updates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/updates"

	payload := strings.NewReader("{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\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/greengrass/updates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 178

{
  "S3UrlSignerRole": "",
  "SoftwareToUpdate": "",
  "UpdateAgentLogLevel": "",
  "UpdateTargets": [],
  "UpdateTargetsArchitecture": "",
  "UpdateTargetsOperatingSystem": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/updates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/updates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\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  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/updates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/updates")
  .header("content-type", "application/json")
  .body("{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  S3UrlSignerRole: '',
  SoftwareToUpdate: '',
  UpdateAgentLogLevel: '',
  UpdateTargets: [],
  UpdateTargetsArchitecture: '',
  UpdateTargetsOperatingSystem: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/updates',
  headers: {'content-type': 'application/json'},
  data: {
    S3UrlSignerRole: '',
    SoftwareToUpdate: '',
    UpdateAgentLogLevel: '',
    UpdateTargets: [],
    UpdateTargetsArchitecture: '',
    UpdateTargetsOperatingSystem: ''
  }
};

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

const url = '{{baseUrl}}/greengrass/updates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"S3UrlSignerRole":"","SoftwareToUpdate":"","UpdateAgentLogLevel":"","UpdateTargets":[],"UpdateTargetsArchitecture":"","UpdateTargetsOperatingSystem":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/updates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "S3UrlSignerRole": "",\n  "SoftwareToUpdate": "",\n  "UpdateAgentLogLevel": "",\n  "UpdateTargets": [],\n  "UpdateTargetsArchitecture": "",\n  "UpdateTargetsOperatingSystem": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/updates")
  .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/greengrass/updates',
  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({
  S3UrlSignerRole: '',
  SoftwareToUpdate: '',
  UpdateAgentLogLevel: '',
  UpdateTargets: [],
  UpdateTargetsArchitecture: '',
  UpdateTargetsOperatingSystem: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/updates',
  headers: {'content-type': 'application/json'},
  body: {
    S3UrlSignerRole: '',
    SoftwareToUpdate: '',
    UpdateAgentLogLevel: '',
    UpdateTargets: [],
    UpdateTargetsArchitecture: '',
    UpdateTargetsOperatingSystem: ''
  },
  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}}/greengrass/updates');

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

req.type('json');
req.send({
  S3UrlSignerRole: '',
  SoftwareToUpdate: '',
  UpdateAgentLogLevel: '',
  UpdateTargets: [],
  UpdateTargetsArchitecture: '',
  UpdateTargetsOperatingSystem: ''
});

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}}/greengrass/updates',
  headers: {'content-type': 'application/json'},
  data: {
    S3UrlSignerRole: '',
    SoftwareToUpdate: '',
    UpdateAgentLogLevel: '',
    UpdateTargets: [],
    UpdateTargetsArchitecture: '',
    UpdateTargetsOperatingSystem: ''
  }
};

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

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

const url = '{{baseUrl}}/greengrass/updates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"S3UrlSignerRole":"","SoftwareToUpdate":"","UpdateAgentLogLevel":"","UpdateTargets":[],"UpdateTargetsArchitecture":"","UpdateTargetsOperatingSystem":""}'
};

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 = @{ @"S3UrlSignerRole": @"",
                              @"SoftwareToUpdate": @"",
                              @"UpdateAgentLogLevel": @"",
                              @"UpdateTargets": @[  ],
                              @"UpdateTargetsArchitecture": @"",
                              @"UpdateTargetsOperatingSystem": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/updates"]
                                                       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}}/greengrass/updates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}" in

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

 "{{baseUrl}}/greengrass/updates",
  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([
    'S3UrlSignerRole' => '',
    'SoftwareToUpdate' => '',
    'UpdateAgentLogLevel' => '',
    'UpdateTargets' => [
        
    ],
    'UpdateTargetsArchitecture' => '',
    'UpdateTargetsOperatingSystem' => ''
  ]),
  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}}/greengrass/updates', [
  'body' => '{
  "S3UrlSignerRole": "",
  "SoftwareToUpdate": "",
  "UpdateAgentLogLevel": "",
  "UpdateTargets": [],
  "UpdateTargetsArchitecture": "",
  "UpdateTargetsOperatingSystem": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'S3UrlSignerRole' => '',
  'SoftwareToUpdate' => '',
  'UpdateAgentLogLevel' => '',
  'UpdateTargets' => [
    
  ],
  'UpdateTargetsArchitecture' => '',
  'UpdateTargetsOperatingSystem' => ''
]));

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

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

append(json_encode([
  'S3UrlSignerRole' => '',
  'SoftwareToUpdate' => '',
  'UpdateAgentLogLevel' => '',
  'UpdateTargets' => [
    
  ],
  'UpdateTargetsArchitecture' => '',
  'UpdateTargetsOperatingSystem' => ''
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/updates');
$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}}/greengrass/updates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "S3UrlSignerRole": "",
  "SoftwareToUpdate": "",
  "UpdateAgentLogLevel": "",
  "UpdateTargets": [],
  "UpdateTargetsArchitecture": "",
  "UpdateTargetsOperatingSystem": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/updates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "S3UrlSignerRole": "",
  "SoftwareToUpdate": "",
  "UpdateAgentLogLevel": "",
  "UpdateTargets": [],
  "UpdateTargetsArchitecture": "",
  "UpdateTargetsOperatingSystem": ""
}'

import http.client

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

payload = "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/greengrass/updates"

payload = {
    "S3UrlSignerRole": "",
    "SoftwareToUpdate": "",
    "UpdateAgentLogLevel": "",
    "UpdateTargets": [],
    "UpdateTargetsArchitecture": "",
    "UpdateTargetsOperatingSystem": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/updates"

payload <- "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\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}}/greengrass/updates")

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  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\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/greengrass/updates') do |req|
  req.body = "{\n  \"S3UrlSignerRole\": \"\",\n  \"SoftwareToUpdate\": \"\",\n  \"UpdateAgentLogLevel\": \"\",\n  \"UpdateTargets\": [],\n  \"UpdateTargetsArchitecture\": \"\",\n  \"UpdateTargetsOperatingSystem\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "S3UrlSignerRole": "",
        "SoftwareToUpdate": "",
        "UpdateAgentLogLevel": "",
        "UpdateTargets": (),
        "UpdateTargetsArchitecture": "",
        "UpdateTargetsOperatingSystem": ""
    });

    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 '{
  "S3UrlSignerRole": "",
  "SoftwareToUpdate": "",
  "UpdateAgentLogLevel": "",
  "UpdateTargets": [],
  "UpdateTargetsArchitecture": "",
  "UpdateTargetsOperatingSystem": ""
}' |  \
  http POST {{baseUrl}}/greengrass/updates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "S3UrlSignerRole": "",\n  "SoftwareToUpdate": "",\n  "UpdateAgentLogLevel": "",\n  "UpdateTargets": [],\n  "UpdateTargetsArchitecture": "",\n  "UpdateTargetsOperatingSystem": ""\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/updates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "S3UrlSignerRole": "",
  "SoftwareToUpdate": "",
  "UpdateAgentLogLevel": "",
  "UpdateTargets": [],
  "UpdateTargetsArchitecture": "",
  "UpdateTargetsOperatingSystem": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/updates")! 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}}/greengrass/definition/subscriptions");

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  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/subscriptions" {:content-type :json
                                                                                :form-params {:InitialVersion {:Subscriptions ""}
                                                                                              :Name ""
                                                                                              :tags {}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/subscriptions"

	payload := strings.NewReader("{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/subscriptions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "InitialVersion": {
    "Subscriptions": ""
  },
  "Name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/subscriptions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/subscriptions")
  .header("content-type", "application/json")
  .body("{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  InitialVersion: {
    Subscriptions: ''
  },
  Name: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/subscriptions',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Subscriptions: ''}, Name: '', tags: {}}
};

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

const url = '{{baseUrl}}/greengrass/definition/subscriptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Subscriptions":""},"Name":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/subscriptions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InitialVersion": {\n    "Subscriptions": ""\n  },\n  "Name": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/subscriptions")
  .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/greengrass/definition/subscriptions',
  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({InitialVersion: {Subscriptions: ''}, Name: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/subscriptions',
  headers: {'content-type': 'application/json'},
  body: {InitialVersion: {Subscriptions: ''}, Name: '', tags: {}},
  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}}/greengrass/definition/subscriptions');

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

req.type('json');
req.send({
  InitialVersion: {
    Subscriptions: ''
  },
  Name: '',
  tags: {}
});

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}}/greengrass/definition/subscriptions',
  headers: {'content-type': 'application/json'},
  data: {InitialVersion: {Subscriptions: ''}, Name: '', tags: {}}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/subscriptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InitialVersion":{"Subscriptions":""},"Name":"","tags":{}}'
};

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 = @{ @"InitialVersion": @{ @"Subscriptions": @"" },
                              @"Name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/subscriptions"]
                                                       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}}/greengrass/definition/subscriptions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/greengrass/definition/subscriptions",
  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([
    'InitialVersion' => [
        'Subscriptions' => ''
    ],
    'Name' => '',
    'tags' => [
        
    ]
  ]),
  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}}/greengrass/definition/subscriptions', [
  'body' => '{
  "InitialVersion": {
    "Subscriptions": ""
  },
  "Name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/subscriptions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InitialVersion' => [
    'Subscriptions' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'InitialVersion' => [
    'Subscriptions' => ''
  ],
  'Name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/subscriptions');
$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}}/greengrass/definition/subscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Subscriptions": ""
  },
  "Name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/subscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InitialVersion": {
    "Subscriptions": ""
  },
  "Name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/subscriptions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/subscriptions"

payload = {
    "InitialVersion": { "Subscriptions": "" },
    "Name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/subscriptions"

payload <- "{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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}}/greengrass/definition/subscriptions")

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  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\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/greengrass/definition/subscriptions') do |req|
  req.body = "{\n  \"InitialVersion\": {\n    \"Subscriptions\": \"\"\n  },\n  \"Name\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InitialVersion": json!({"Subscriptions": ""}),
        "Name": "",
        "tags": 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 '{
  "InitialVersion": {
    "Subscriptions": ""
  },
  "Name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/greengrass/definition/subscriptions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InitialVersion": {\n    "Subscriptions": ""\n  },\n  "Name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/subscriptions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InitialVersion": ["Subscriptions": ""],
  "Name": "",
  "tags": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/subscriptions")! 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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions");

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  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions" {:content-type :json
                                                                                                                   :form-params {:Subscriptions [{:Id ""
                                                                                                                                                  :Source ""
                                                                                                                                                  :Subject ""
                                                                                                                                                  :Target ""}]}})

require "http/client"

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"),
    Content = new StringContent("{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"

	payload := strings.NewReader("{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "Subscriptions": [
    {
      "Id": "",
      "Source": "",
      "Subject": "",
      "Target": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Subscriptions: [
    {
      Id: '',
      Source: '',
      Subject: '',
      Target: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Subscriptions: [{Id: '', Source: '', Subject: '', Target: ''}]}
};

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

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Subscriptions":[{"Id":"","Source":"","Subject":"","Target":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Subscriptions": [\n    {\n      "Id": "",\n      "Source": "",\n      "Subject": "",\n      "Target": ""\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  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions")
  .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/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions',
  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({Subscriptions: [{Id: '', Source: '', Subject: '', Target: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  body: {Subscriptions: [{Id: '', Source: '', Subject: '', Target: ''}]},
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions');

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

req.type('json');
req.send({
  Subscriptions: [
    {
      Id: '',
      Source: '',
      Subject: '',
      Target: ''
    }
  ]
});

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions',
  headers: {'content-type': 'application/json'},
  data: {Subscriptions: [{Id: '', Source: '', Subject: '', Target: ''}]}
};

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

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

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Subscriptions":[{"Id":"","Source":"","Subject":"","Target":""}]}'
};

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 = @{ @"Subscriptions": @[ @{ @"Id": @"", @"Source": @"", @"Subject": @"", @"Target": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"]
                                                       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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions",
  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([
    'Subscriptions' => [
        [
                'Id' => '',
                'Source' => '',
                'Subject' => '',
                'Target' => ''
        ]
    ]
  ]),
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions', [
  'body' => '{
  "Subscriptions": [
    {
      "Id": "",
      "Source": "",
      "Subject": "",
      "Target": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Subscriptions' => [
    [
        'Id' => '',
        'Source' => '',
        'Subject' => '',
        'Target' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Subscriptions' => [
    [
        'Id' => '',
        'Source' => '',
        'Subject' => '',
        'Target' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions');
$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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Subscriptions": [
    {
      "Id": "",
      "Source": "",
      "Subject": "",
      "Target": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Subscriptions": [
    {
      "Id": "",
      "Source": "",
      "Subject": "",
      "Target": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"

payload = { "Subscriptions": [
        {
            "Id": "",
            "Source": "",
            "Subject": "",
            "Target": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions"

payload <- "{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions")

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  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions') do |req|
  req.body = "{\n  \"Subscriptions\": [\n    {\n      \"Id\": \"\",\n      \"Source\": \"\",\n      \"Subject\": \"\",\n      \"Target\": \"\"\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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions";

    let payload = json!({"Subscriptions": (
            json!({
                "Id": "",
                "Source": "",
                "Subject": "",
                "Target": ""
            })
        )});

    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 '{
  "Subscriptions": [
    {
      "Id": "",
      "Source": "",
      "Subject": "",
      "Target": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Subscriptions": [\n    {\n      "Id": "",\n      "Source": "",\n      "Subject": "",\n      "Target": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Subscriptions": [
    [
      "Id": "",
      "Source": "",
      "Subject": "",
      "Target": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions")! 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}}/greengrass/definition/connectors/:ConnectorDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

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

var client = new RestClient("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId'
};

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

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId';
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}}/greengrass/definition/connectors/:ConnectorDefinitionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId',
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId');

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}}/greengrass/definition/connectors/:ConnectorDefinitionId'
};

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

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

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId';
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}}/greengrass/definition/connectors/:ConnectorDefinitionId"]
                                                       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}}/greengrass/definition/connectors/:ConnectorDefinitionId" in

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

 "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId",
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId")

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")

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/greengrass/definition/connectors/:ConnectorDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/greengrass/definition/connectors/:ConnectorDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

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

var client = new RestClient("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId'
};

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

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId';
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}}/greengrass/definition/cores/:CoreDefinitionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/cores/:CoreDefinitionId',
  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}}/greengrass/definition/cores/:CoreDefinitionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId');

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}}/greengrass/definition/cores/:CoreDefinitionId'
};

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

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

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId';
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}}/greengrass/definition/cores/:CoreDefinitionId"]
                                                       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}}/greengrass/definition/cores/:CoreDefinitionId" in

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

 "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId",
  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}}/greengrass/definition/cores/:CoreDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/greengrass/definition/cores/:CoreDefinitionId")

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")

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/greengrass/definition/cores/:CoreDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/greengrass/definition/cores/:CoreDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

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

var client = new RestClient("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId'
};

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

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId';
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}}/greengrass/definition/devices/:DeviceDefinitionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId');

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}}/greengrass/definition/devices/:DeviceDefinitionId'
};

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

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

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId';
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}}/greengrass/definition/devices/:DeviceDefinitionId"]
                                                       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}}/greengrass/definition/devices/:DeviceDefinitionId" in

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

 "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId",
  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}}/greengrass/definition/devices/:DeviceDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/greengrass/definition/devices/:DeviceDefinitionId")

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")

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/greengrass/definition/devices/:DeviceDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/greengrass/definition/devices/:DeviceDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

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

var client = new RestClient("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId'
};

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

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId';
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}}/greengrass/definition/functions/:FunctionDefinitionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/functions/:FunctionDefinitionId',
  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}}/greengrass/definition/functions/:FunctionDefinitionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId');

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}}/greengrass/definition/functions/:FunctionDefinitionId'
};

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

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

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId';
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}}/greengrass/definition/functions/:FunctionDefinitionId"]
                                                       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}}/greengrass/definition/functions/:FunctionDefinitionId" in

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

 "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId",
  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}}/greengrass/definition/functions/:FunctionDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/greengrass/definition/functions/:FunctionDefinitionId")

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

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

import requests

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")

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/greengrass/definition/functions/:FunctionDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/greengrass/definition/functions/:FunctionDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/groups/:GroupId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/greengrass/groups/:GroupId")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/groups/:GroupId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/groups/:GroupId');

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}}/greengrass/groups/:GroupId'
};

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

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

const url = '{{baseUrl}}/greengrass/groups/:GroupId';
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}}/greengrass/groups/:GroupId"]
                                                       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}}/greengrass/groups/:GroupId" in

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

 "{{baseUrl}}/greengrass/groups/:GroupId",
  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}}/greengrass/groups/:GroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/greengrass/groups/:GroupId")

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

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

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId")

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/greengrass/groups/:GroupId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/greengrass/groups/:GroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

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

var client = new RestClient("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId'
};

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

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId';
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}}/greengrass/definition/loggers/:LoggerDefinitionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId',
  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}}/greengrass/definition/loggers/:LoggerDefinitionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId');

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}}/greengrass/definition/loggers/:LoggerDefinitionId'
};

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

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

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId';
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}}/greengrass/definition/loggers/:LoggerDefinitionId"]
                                                       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}}/greengrass/definition/loggers/:LoggerDefinitionId" in

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

 "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId",
  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}}/greengrass/definition/loggers/:LoggerDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")

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/greengrass/definition/loggers/:LoggerDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId";

    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}}/greengrass/definition/loggers/:LoggerDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

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}}/greengrass/definition/resources/:ResourceDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

	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/greengrass/definition/resources/:ResourceDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"))
    .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}}/greengrass/definition/resources/:ResourceDefinitionId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")
  .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}}/greengrass/definition/resources/:ResourceDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId';
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}}/greengrass/definition/resources/:ResourceDefinitionId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/resources/:ResourceDefinitionId',
  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}}/greengrass/definition/resources/:ResourceDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId');

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}}/greengrass/definition/resources/:ResourceDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId';
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}}/greengrass/definition/resources/:ResourceDefinitionId"]
                                                       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}}/greengrass/definition/resources/:ResourceDefinitionId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId",
  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}}/greengrass/definition/resources/:ResourceDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/greengrass/definition/resources/:ResourceDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")

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/greengrass/definition/resources/:ResourceDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId";

    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}}/greengrass/definition/resources/:ResourceDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

	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/greengrass/definition/subscriptions/:SubscriptionDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"))
    .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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId';
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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId',
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId';
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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"]
                                                       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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId",
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")

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/greengrass/definition/subscriptions/:SubscriptionDefinitionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId";

    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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/groups/:GroupId/role");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/greengrass/groups/:GroupId/role")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/role"

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}}/greengrass/groups/:GroupId/role"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/role");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/role"

	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/greengrass/groups/:GroupId/role HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/greengrass/groups/:GroupId/role")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/role"))
    .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}}/greengrass/groups/:GroupId/role")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .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}}/greengrass/groups/:GroupId/role');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId/role';
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}}/greengrass/groups/:GroupId/role',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/role',
  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}}/greengrass/groups/:GroupId/role'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/groups/:GroupId/role');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId/role';
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}}/greengrass/groups/:GroupId/role"]
                                                       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}}/greengrass/groups/:GroupId/role" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId/role",
  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}}/greengrass/groups/:GroupId/role');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/role');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/role');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/role' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/role' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/greengrass/groups/:GroupId/role")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/role"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/role"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/role")

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/greengrass/groups/:GroupId/role') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId/role";

    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}}/greengrass/groups/:GroupId/role

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/role

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/role")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/greengrass/servicerole");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/greengrass/servicerole")

require "http/client"

url = "{{baseUrl}}/greengrass/servicerole"

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}}/greengrass/servicerole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/servicerole");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/servicerole"

	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/greengrass/servicerole HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/greengrass/servicerole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/servicerole"))
    .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}}/greengrass/servicerole")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/greengrass/servicerole")
  .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}}/greengrass/servicerole');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/greengrass/servicerole'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/servicerole';
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}}/greengrass/servicerole',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/servicerole")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/servicerole',
  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}}/greengrass/servicerole'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/greengrass/servicerole');

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}}/greengrass/servicerole'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/servicerole';
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}}/greengrass/servicerole"]
                                                       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}}/greengrass/servicerole" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/servicerole",
  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}}/greengrass/servicerole');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/servicerole');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/servicerole');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/servicerole' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/servicerole' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/greengrass/servicerole")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/servicerole"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/servicerole"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/servicerole")

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/greengrass/servicerole') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/servicerole";

    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}}/greengrass/servicerole

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/greengrass/servicerole

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/servicerole")! 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}}/greengrass/groups/:GroupId/role");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/groups/:GroupId/role")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/role"

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}}/greengrass/groups/:GroupId/role"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/role");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/role"

	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/greengrass/groups/:GroupId/role HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/groups/:GroupId/role")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/role"))
    .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}}/greengrass/groups/:GroupId/role")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .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}}/greengrass/groups/:GroupId/role');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId/role';
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}}/greengrass/groups/:GroupId/role',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/role")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/role',
  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}}/greengrass/groups/:GroupId/role'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/groups/:GroupId/role');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/role'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId/role';
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}}/greengrass/groups/:GroupId/role"]
                                                       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}}/greengrass/groups/:GroupId/role" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId/role",
  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}}/greengrass/groups/:GroupId/role');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/role');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/role');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/role' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/role' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/groups/:GroupId/role")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/role"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/role"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/role")

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/greengrass/groups/:GroupId/role') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId/role";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/groups/:GroupId/role

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/role

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/role")! 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}}/greengrass/bulk/deployments/:BulkDeploymentId/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status")

require "http/client"

url = "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status"

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}}/greengrass/bulk/deployments/:BulkDeploymentId/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status"

	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/greengrass/bulk/deployments/:BulkDeploymentId/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status"))
    .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}}/greengrass/bulk/deployments/:BulkDeploymentId/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status")
  .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}}/greengrass/bulk/deployments/:BulkDeploymentId/status');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status';
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}}/greengrass/bulk/deployments/:BulkDeploymentId/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/bulk/deployments/:BulkDeploymentId/status',
  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}}/greengrass/bulk/deployments/:BulkDeploymentId/status'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status');

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}}/greengrass/bulk/deployments/:BulkDeploymentId/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status';
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}}/greengrass/bulk/deployments/:BulkDeploymentId/status"]
                                                       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}}/greengrass/bulk/deployments/:BulkDeploymentId/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status",
  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}}/greengrass/bulk/deployments/:BulkDeploymentId/status');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/bulk/deployments/:BulkDeploymentId/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status")

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/greengrass/bulk/deployments/:BulkDeploymentId/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/bulk/deployments/:BulkDeploymentId/status")! 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}}/greengrass/things/:ThingName/connectivityInfo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo")

require "http/client"

url = "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo"

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}}/greengrass/things/:ThingName/connectivityInfo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo"

	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/greengrass/things/:ThingName/connectivityInfo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo"))
    .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}}/greengrass/things/:ThingName/connectivityInfo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo")
  .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}}/greengrass/things/:ThingName/connectivityInfo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo';
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}}/greengrass/things/:ThingName/connectivityInfo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/things/:ThingName/connectivityInfo',
  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}}/greengrass/things/:ThingName/connectivityInfo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo');

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}}/greengrass/things/:ThingName/connectivityInfo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo';
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}}/greengrass/things/:ThingName/connectivityInfo"]
                                                       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}}/greengrass/things/:ThingName/connectivityInfo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo",
  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}}/greengrass/things/:ThingName/connectivityInfo');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/things/:ThingName/connectivityInfo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo")

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/greengrass/things/:ThingName/connectivityInfo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/things/:ThingName/connectivityInfo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/things/:ThingName/connectivityInfo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/things/:ThingName/connectivityInfo")! 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}}/greengrass/definition/connectors/:ConnectorDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

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}}/greengrass/definition/connectors/:ConnectorDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

	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/greengrass/definition/connectors/:ConnectorDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"))
    .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}}/greengrass/definition/connectors/:ConnectorDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")
  .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}}/greengrass/definition/connectors/:ConnectorDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId';
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}}/greengrass/definition/connectors/:ConnectorDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId',
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId');

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}}/greengrass/definition/connectors/:ConnectorDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId';
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}}/greengrass/definition/connectors/:ConnectorDefinitionId"]
                                                       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}}/greengrass/definition/connectors/:ConnectorDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId",
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")

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/greengrass/definition/connectors/:ConnectorDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId")! 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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"

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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"

	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/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"))
    .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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")
  .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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId';
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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId',
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId');

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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId';
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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"]
                                                       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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId",
  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}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")

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/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/connectors/:ConnectorDefinitionId/versions/:ConnectorDefinitionVersionId")! 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}}/greengrass/definition/cores/:CoreDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

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}}/greengrass/definition/cores/:CoreDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

	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/greengrass/definition/cores/:CoreDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"))
    .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}}/greengrass/definition/cores/:CoreDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")
  .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}}/greengrass/definition/cores/:CoreDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId';
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}}/greengrass/definition/cores/:CoreDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/cores/:CoreDefinitionId',
  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}}/greengrass/definition/cores/:CoreDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId');

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}}/greengrass/definition/cores/:CoreDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId';
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}}/greengrass/definition/cores/:CoreDefinitionId"]
                                                       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}}/greengrass/definition/cores/:CoreDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId",
  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}}/greengrass/definition/cores/:CoreDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/cores/:CoreDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")

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/greengrass/definition/cores/:CoreDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId")! 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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"

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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"

	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/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"))
    .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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")
  .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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId';
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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId',
  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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId');

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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId';
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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"]
                                                       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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId",
  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}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")

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/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/cores/:CoreDefinitionId/versions/:CoreDefinitionVersionId")! 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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"

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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"

	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/greengrass/groups/:GroupId/deployments/:DeploymentId/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"))
    .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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")
  .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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status';
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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/deployments/:DeploymentId/status',
  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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status');

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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status';
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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"]
                                                       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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status",
  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}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/groups/:GroupId/deployments/:DeploymentId/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")

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/greengrass/groups/:GroupId/deployments/:DeploymentId/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/deployments/:DeploymentId/status")! 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}}/greengrass/definition/devices/:DeviceDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

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}}/greengrass/definition/devices/:DeviceDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

	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/greengrass/definition/devices/:DeviceDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"))
    .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}}/greengrass/definition/devices/:DeviceDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")
  .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}}/greengrass/definition/devices/:DeviceDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId';
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}}/greengrass/definition/devices/:DeviceDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/devices/:DeviceDefinitionId',
  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}}/greengrass/definition/devices/:DeviceDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId');

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}}/greengrass/definition/devices/:DeviceDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId';
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}}/greengrass/definition/devices/:DeviceDefinitionId"]
                                                       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}}/greengrass/definition/devices/:DeviceDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId",
  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}}/greengrass/definition/devices/:DeviceDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/devices/:DeviceDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")

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/greengrass/definition/devices/:DeviceDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId")! 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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"

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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"

	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/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"))
    .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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")
  .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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId';
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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId',
  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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId');

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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId';
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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"]
                                                       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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId",
  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}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")

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/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/devices/:DeviceDefinitionId/versions/:DeviceDefinitionVersionId")! 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}}/greengrass/definition/functions/:FunctionDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

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}}/greengrass/definition/functions/:FunctionDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

	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/greengrass/definition/functions/:FunctionDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"))
    .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}}/greengrass/definition/functions/:FunctionDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")
  .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}}/greengrass/definition/functions/:FunctionDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId';
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}}/greengrass/definition/functions/:FunctionDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/functions/:FunctionDefinitionId',
  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}}/greengrass/definition/functions/:FunctionDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId');

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}}/greengrass/definition/functions/:FunctionDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId';
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}}/greengrass/definition/functions/:FunctionDefinitionId"]
                                                       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}}/greengrass/definition/functions/:FunctionDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId",
  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}}/greengrass/definition/functions/:FunctionDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/functions/:FunctionDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")

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/greengrass/definition/functions/:FunctionDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId")! 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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"

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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"

	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/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"))
    .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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")
  .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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId';
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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId',
  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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId');

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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId';
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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"]
                                                       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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId",
  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}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")

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/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/functions/:FunctionDefinitionId/versions/:FunctionDefinitionVersionId")! 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}}/greengrass/groups/:GroupId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/groups/:GroupId")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId"

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}}/greengrass/groups/:GroupId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId"

	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/greengrass/groups/:GroupId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/groups/:GroupId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId"))
    .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}}/greengrass/groups/:GroupId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/groups/:GroupId")
  .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}}/greengrass/groups/:GroupId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/greengrass/groups/:GroupId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId';
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}}/greengrass/groups/:GroupId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId',
  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}}/greengrass/groups/:GroupId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/groups/:GroupId');

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}}/greengrass/groups/:GroupId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId';
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}}/greengrass/groups/:GroupId"]
                                                       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}}/greengrass/groups/:GroupId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId",
  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}}/greengrass/groups/:GroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/groups/:GroupId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId")

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/greengrass/groups/:GroupId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/groups/:GroupId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId")! 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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"

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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"

	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/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"))
    .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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")
  .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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId';
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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId',
  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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId');

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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId';
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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"]
                                                       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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId",
  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}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")

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/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/:CertificateAuthorityId")! 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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"

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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"

	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/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"))
    .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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")
  .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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry';
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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry',
  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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry');

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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry';
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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"]
                                                       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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry",
  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}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")

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/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/certificateauthorities/configuration/expiry")! 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}}/greengrass/groups/:GroupId/versions/:GroupVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId"

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}}/greengrass/groups/:GroupId/versions/:GroupVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId"

	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/greengrass/groups/:GroupId/versions/:GroupVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId"))
    .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}}/greengrass/groups/:GroupId/versions/:GroupVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId")
  .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}}/greengrass/groups/:GroupId/versions/:GroupVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId';
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}}/greengrass/groups/:GroupId/versions/:GroupVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/groups/:GroupId/versions/:GroupVersionId',
  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}}/greengrass/groups/:GroupId/versions/:GroupVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId');

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}}/greengrass/groups/:GroupId/versions/:GroupVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId';
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}}/greengrass/groups/:GroupId/versions/:GroupVersionId"]
                                                       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}}/greengrass/groups/:GroupId/versions/:GroupVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId",
  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}}/greengrass/groups/:GroupId/versions/:GroupVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/groups/:GroupId/versions/:GroupVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId")

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/greengrass/groups/:GroupId/versions/:GroupVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/groups/:GroupId/versions/:GroupVersionId")! 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}}/greengrass/definition/loggers/:LoggerDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

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}}/greengrass/definition/loggers/:LoggerDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

	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/greengrass/definition/loggers/:LoggerDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"))
    .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}}/greengrass/definition/loggers/:LoggerDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")
  .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}}/greengrass/definition/loggers/:LoggerDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId';
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}}/greengrass/definition/loggers/:LoggerDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId',
  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}}/greengrass/definition/loggers/:LoggerDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId');

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}}/greengrass/definition/loggers/:LoggerDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId';
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}}/greengrass/definition/loggers/:LoggerDefinitionId"]
                                                       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}}/greengrass/definition/loggers/:LoggerDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId",
  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}}/greengrass/definition/loggers/:LoggerDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")

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/greengrass/definition/loggers/:LoggerDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId")! 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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"

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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"

	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/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"))
    .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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")
  .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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId';
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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId',
  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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId');

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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId';
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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"]
                                                       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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId",
  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}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")

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/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/loggers/:LoggerDefinitionId/versions/:LoggerDefinitionVersionId")! 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}}/greengrass/definition/resources/:ResourceDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

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}}/greengrass/definition/resources/:ResourceDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

	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/greengrass/definition/resources/:ResourceDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"))
    .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}}/greengrass/definition/resources/:ResourceDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")
  .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}}/greengrass/definition/resources/:ResourceDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId';
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}}/greengrass/definition/resources/:ResourceDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/resources/:ResourceDefinitionId',
  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}}/greengrass/definition/resources/:ResourceDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId');

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}}/greengrass/definition/resources/:ResourceDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId';
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}}/greengrass/definition/resources/:ResourceDefinitionId"]
                                                       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}}/greengrass/definition/resources/:ResourceDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId",
  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}}/greengrass/definition/resources/:ResourceDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/resources/:ResourceDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")

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/greengrass/definition/resources/:ResourceDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId")! 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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"

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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"

	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/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"))
    .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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")
  .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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId';
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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId',
  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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId');

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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId';
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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"]
                                                       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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId",
  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}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")

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/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/resources/:ResourceDefinitionId/versions/:ResourceDefinitionVersionId")! 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}}/greengrass/servicerole");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/servicerole")

require "http/client"

url = "{{baseUrl}}/greengrass/servicerole"

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}}/greengrass/servicerole"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/servicerole");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/servicerole"

	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/greengrass/servicerole HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/servicerole")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/servicerole"))
    .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}}/greengrass/servicerole")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/servicerole")
  .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}}/greengrass/servicerole');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/greengrass/servicerole'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/servicerole';
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}}/greengrass/servicerole',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/servicerole")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/servicerole',
  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}}/greengrass/servicerole'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/servicerole');

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}}/greengrass/servicerole'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/servicerole';
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}}/greengrass/servicerole"]
                                                       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}}/greengrass/servicerole" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/servicerole",
  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}}/greengrass/servicerole');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/servicerole');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/servicerole');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/servicerole' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/servicerole' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/servicerole")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/servicerole"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/servicerole"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/servicerole")

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/greengrass/servicerole') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/servicerole";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/servicerole

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/servicerole

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/servicerole")! 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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

	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/greengrass/definition/subscriptions/:SubscriptionDefinitionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"))
    .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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId';
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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId',
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId';
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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"]
                                                       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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId",
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")

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/greengrass/definition/subscriptions/:SubscriptionDefinitionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId")! 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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")

require "http/client"

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"

	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/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"))
    .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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")
  .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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId';
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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId',
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId');

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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId';
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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"]
                                                       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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId",
  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}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")

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/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/greengrass/definition/subscriptions/:SubscriptionDefinitionId/versions/:SubscriptionDefinitionVersionId")! 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}}/greengrass/things/:ThingName/runtimeconfig");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/greengrass/things/:ThingName/runtimeconfig")

require "http/client"

url = "{{baseUrl}}/greengrass/things/:ThingName/runtimeconfig"

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}}/greengrass/things/:ThingName/runtimeconfig"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/greengrass/things/:ThingName/runtimeconfig");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);